@bluewombat/conductor 0.8.0 → 0.10.0

package/dist/run/open-conductor.js

@@ -1,19 +1,12 @@
 import { existsSync } from "node:fs";
 import { readdir, rm, stat } from "node:fs/promises";
 import { isAbsolute, join, resolve } from "node:path";
-import { featureWorkspacePath, subtaskWorkspacePath } from "./paths.js";
+import { openDelivery, reasonOfTraces, } from "./delivery.js";
+import { ticketWorkspacePath } from "./paths.js";
+import { foldMessageOf, subjectOf } from "./subject.js";
+export { foldMessageOf, subjectOf } from "./subject.js";
 const DEFAULT_MAX_REFUSALS = 3;
 const DEFAULT_TRANSFORMER_DURATION_MS = 30_000;
-function featureJsonOf(admission) {
-    const document = {
-        key: admission.key,
-        intention: admission.intention,
-    };
-    if (admission.title !== undefined) {
-        document.title = admission.title;
-    }
-    return JSON.stringify(document);
-}
 async function isDirectory(path) {
     try {
         return (await stat(path)).isDirectory();
@@ -25,14 +18,27 @@ async function isDirectory(path) {
 async function destroy(path) {
     await rm(path, { recursive: true, force: true });
 }
+/** What the next pass is told when it picks up a workspace the earlier one did not finish. */
+const RESUMED_NOTE = "The pass before this one was stopped before it finished. What it made is in this directory: look at it before you write, and do not start over.";
 /**
- * Where a feature's workspace is: the path the ledger declared when it was
- * made, else the one the current layout gives. The declared path wins because a
- * feature in flight — escalated, resumed — keeps its work and its git branch
- * where they were; a layout that changed since must not strand them.
+ * Where a Ticket's workspace is: the path the ledger declared when it was
+ * made, else the one the layout gives. The declared path wins because a
+ * Ticket in flight keeps its work and its git branch where they were.
  */
-function declaredFeaturePath(workspaceRoot, key, aggregate) {
-    return aggregate?.workspaces?.feature ?? featureWorkspacePath(workspaceRoot, key);
+function declaredTicketPath(workspaceRoot, key, aggregate) {
+    return aggregate?.workspace ?? ticketWorkspacePath(workspaceRoot, key);
+}
+/** Whether a workspace the ledger declares is still there with something in it. */
+async function stillThere(path) {
+    if (path === undefined) {
+        return false;
+    }
+    try {
+        return (await readdir(path)).length > 0;
+    }
+    catch {
+        return false;
+    }
 }
 async function destroyOrphans(workspaceRoot, allowed) {
     if (!(await isDirectory(workspaceRoot))) {
@@ -59,38 +65,6 @@ async function destroyOrphans(workspaceRoot, allowed) {
         }
     }
 }
-const SUBJECT_MAX = 72;
-/**
- * A fold's subject out of prose. Text written the way a commit is — a headline,
- * a blank line, the rest — gives its headline. Otherwise the first sentence,
- * cut at a word when even that runs past what one line of history shows. A
- * subject is not markdown, so the backticks prose uses for names come off; and
- * it ends on a word, not on an ellipsis — the whole text follows in the body
- * for whoever wants it.
- */
-export function subjectOf(text) {
-    const trimmed = text.trim();
-    const headline = /^([^\n]+)\n\s*\n/.exec(trimmed)?.[1];
-    const oneLine = (headline ?? trimmed).replace(/\s+/g, " ");
-    // A sentence ends where the next one starts with a capital, or where the
-    // text ends: "e.g. foo" and "src/index.js" are not sentence ends.
-    const sentence = /^(.*?[.!?])(?:\s+(?=[A-Z\p{Lu}])|$)/u.exec(oneLine)?.[1] ?? oneLine;
-    const candidate = sentence.replace(/`/g, "").replace(/[.:;,\s]+$/, "");
-    if (candidate.length <= SUBJECT_MAX) {
-        return candidate;
-    }
-    const cut = candidate.slice(0, SUBJECT_MAX);
-    const atWord = cut.lastIndexOf(" ");
-    return (atWord > SUBJECT_MAX / 2 ? cut.slice(0, atWord) : cut).replace(/[.:;,\s]+$/, "");
-}
-/** Subject line, then the whole text when the subject did not carry it all. */
-export function foldMessageOf(text) {
-    const subject = subjectOf(text);
-    const whole = text.trim();
-    return subject === whole || subject === whole.replace(/[.\s]+$/, "")
-        ? subject
-        : `${subject}\n\n${whole}`;
-}
 export function openConductor(options) {
     if (!isAbsolute(options.workLineStable) || !isAbsolute(options.workspaceRoot)) {
         throw new Error("Conductor workLineStable and workspaceRoot must be absolute directories.");
@@ -113,26 +87,40 @@ export function openConductor(options) {
     const durationMs = options.transformerDurationMs ?? DEFAULT_TRANSFORMER_DURATION_MS;
     const authority = options.authority;
     const workLineTarget = options.workLineTarget ?? "";
+    /** The line a Ticket lands on: its own when it names one, else the Project's. */
+    const targetOf = (aggregate) => aggregate.intention.line ?? workLineTarget;
     const maxRefusals = options.maxRefusals ?? DEFAULT_MAX_REFUSALS;
-    const assemblyValidate = options.assemblyValidate ?? false;
-    const assemblyFixDeclared = options.assemblyFixDeclared ?? false;
+    const validate = options.validate ?? false;
+    const testsFirst = options.tests ?? false;
+    const fixDeclared = options.fixDeclared ?? false;
     const warm = options.warm;
-    /** Features whose warm already succeeded in this Conductor instance. */
-    const warmed = new Set();
+    const maxParallel = options.maxParallel ?? 1;
+    const line = options.line;
     let paused = false;
+    /**
+     * One at a time over the shared copy of the work line. What runs under it is
+     * brief and git's own — cutting a worktree from the copy, merging the copy
+     * in — while what takes minutes (the agents, the Gates) runs in the Ticket's
+     * own workspace, outside it.
+     */
+    let lastOnLine = Promise.resolve();
+    const onLine = (job) => {
+        const run = lastOnLine.then(job, job);
+        lastOnLine = run.catch(() => undefined);
+        return run;
+    };
+    /** The copy brought up to the line `target`, or why it could not be. */
+    const refreshLine = async (target) => {
+        if (line === undefined || target.length === 0) {
+            return { ok: true };
+        }
+        const refreshed = await line.refresh(target);
+        return refreshed.ok ? { ok: true } : { ok: false };
+    };
     const refused = (code) => ({
         outcome: "refused",
         code,
     });
-    /** What the last Attempt ended on, for whoever reads the escalation. */
-    const reasonOfTraces = (traces) => {
-        const last = traces.at(-1);
-        const report = last?.report?.trim();
-        if (report === undefined || report.length === 0) {
-            return undefined;
-        }
-        return last?.refusedBy === undefined ? report : `${last.refusedBy}: ${report}`;
-    };
     const fromLedger = (result) => {
         if (result.ok) {
             return undefined;
@@ -149,13 +137,13 @@ export function openConductor(options) {
         return refused("illegal-transition");
     };
     /**
-     * Freeze the Feature for a human. If a newer fingerprint arrived in flight,
+     * Freeze the Ticket for a human. If a newer fingerprint arrived in flight,
      * it is named on the escalation and consumed by the ledger.
      */
     async function freeze(key, input) {
         const got = await ledger.get(key);
         const pending = got.ok && got.aggregate.pending_fingerprint !== undefined
-            ? `The intention was edited while the work was in flight (now fingerprint ${got.aggregate.pending_fingerprint}). The work stops here for a human to decide: on resume it is planned again from the new words, and what already landed is kept.`
+            ? `The intention was edited while the work was in flight (now fingerprint ${got.aggregate.pending_fingerprint}). The work stops here for a human to decide: on resume the work starts again from zero.`
             : undefined;
         const report = [input.report, pending]
             .filter((part) => part !== undefined && part.length > 0)
@@ -163,7 +151,6 @@ export function openConductor(options) {
         const escalated = await ledger.escalate({
             key,
             kind: input.kind,
-            ...(input.subtaskId === undefined ? {} : { subtaskId: input.subtaskId }),
             ...(report.length === 0 ? {} : { report }),
         });
         const failure = fromLedger(escalated);
@@ -177,48 +164,136 @@ export function openConductor(options) {
         if (!got.ok || got.aggregate.pending_fingerprint === undefined) {
             return undefined;
         }
-        return await freeze(key, { kind: "plan" });
+        return await freeze(key, { kind: "unit" });
     }
+    /**
+     * What the corrective rounds of one ticket have used. A refusal, a conflict, a
+     * recheck that failed and a line that moved on all draw on the one
+     * `maxRefusals` budget: whichever loop it is, the ticket stops being corrected
+     * when it is empty, not once per loop.
+     */
+    function spentOf(aggregate) {
+        return ((aggregate.submission?.refusals ?? 0) +
+            (aggregate.parked_refusals ?? 0) +
+            (aggregate.submission?.realigns ?? 0));
+    }
+    /** What a Ticket's delivery reads of it, and how it keeps what the delivery decides. */
+    function ticketStore(key) {
+        return {
+            async read() {
+                const got = await ledger.get(key);
+                if (!got.ok) {
+                    return undefined;
+                }
+                const aggregate = got.aggregate;
+                // A parked refusal is this round's; a Submission's is carried forward on
+                // purpose and may already be repaired. The fresher one wins.
+                const parked = aggregate.parked_refusal;
+                const report = parked?.report ?? aggregate.submission?.last_report;
+                const refusedBy = parked?.refused_by ?? aggregate.submission?.last_refused_by;
+                return {
+                    sentBack: report === undefined ? undefined : { report, refusedBy },
+                    spent: spentOf(aggregate),
+                    submission: aggregate.submission === undefined
+                        ? undefined
+                        : { reference: aggregate.submission.reference },
+                };
+            },
+            freeze: async (input) => await freeze(key, input),
+            park: async (why) => fromLedger(await ledger.recordParkedRefusal({
+                key,
+                report: why.report,
+                ...(why.refusedBy === undefined ? {} : { refusedBy: why.refusedBy }),
+            })),
+            unpark: async () => fromLedger(await ledger.clearParkedRefusal(key)),
+            refuse: async (why) => fromLedger(await ledger.recordRefusal({
+                key,
+                report: why.report,
+                ...(why.refusedBy === undefined ? {} : { refusedBy: why.refusedBy }),
+            })),
+            realign: async () => fromLedger(await ledger.recordRealign({ key })),
+        };
+    }
+    /** Where a Ticket's work is and where it goes. */
+    function unitOf(key, aggregate) {
+        const workspace = declaredTicketPath(workspaceRoot, key, aggregate);
+        return {
+            key,
+            intention: aggregate.intention.intention,
+            title: aggregate.intention.title,
+            noun: "ticket",
+            workspace,
+            judgeWorkspace: workspace,
+            target: targetOf(aggregate),
+            line: workLineStable,
+        };
+    }
+    const delivery = openDelivery({
+        transformers,
+        authority,
+        durationMs,
+        maxRefusals,
+        recheck: true,
+        validate,
+        fixDeclared,
+        onLine,
+        refreshLine: async (target) => (await refreshLine(target)).ok,
+        isPaused: () => paused,
+    });
+    /** A unit nobody is on any more: its lease runs out. Its workspace stays, for the next pass. */
     async function expireIfHeld(key) {
-        const expired = await ledger.expireBail(key);
-        if (expired.ok) {
-            const got = await ledger.get(key);
-            if (got.ok && got.aggregate.workspaces?.subtask !== undefined) {
-                await destroy(got.aggregate.workspaces.subtask);
-            }
-        }
+        await ledger.expireBail(key);
     }
     /**
-     * A Subtask was started and a transformer stopped on interrupt. Release the
+     * A unit was started and a transformer stopped on interrupt. Release the
      * bail now so the next process does not wait an hour for the clock.
+     *
+     * The workspace stays, and so do the Attempts the pass finished: stopping Mason is not a
+     * failure of the work, so the next pass picks it up where it was instead of starting over.
+     * Whoever wants it started over says so (`release`).
      */
-    async function releaseHeldAfterInterrupt(key) {
+    async function releaseHeldAfterInterrupt(key, traces = []) {
         const before = await ledger.get(key);
-        const child = before.ok ? before.aggregate.workspaces?.subtask : undefined;
-        const released = await ledger.releaseBail(key);
-        if (!released.ok) {
-            if (released.code === "persist-failed") {
-                return refused("persist-failed");
+        if (before.ok) {
+            let number = before.aggregate.attempts.length + 1;
+            for (const trace of traces) {
+                if (trace.ended === "interrupted") {
+                    continue;
+                }
+                const recorded = await recordFinished(key, number, trace);
+                if (recorded !== undefined) {
+                    return recorded;
+                }
+                number += 1;
             }
-            // Already free, or a state releaseBail refuses — leave the ledger and
-            // still answer interrupted.
-            return undefined;
         }
-        if (child !== undefined) {
-            await destroy(child);
+        const released = await ledger.releaseBail(key);
+        if (!released.ok && released.code === "persist-failed") {
+            return refused("persist-failed");
         }
+        // Already free, or a state releaseBail refuses — leave the ledger and
+        // still answer interrupted.
         return undefined;
     }
+    async function recordFinished(key, number, trace) {
+        const recorded = await ledger.recordAttempt({
+            key,
+            number,
+            trace: {
+                ended: trace.ended,
+                ...(trace.report === undefined || trace.report.length === 0
+                    ? {}
+                    : { report: trace.report }),
+                ...(trace.refusedBy === undefined ? {} : { refusedBy: trace.refusedBy }),
+            },
+        });
+        return fromLedger(recorded);
+    }
     async function reconcile(project) {
         const declared = await ledger.listDeclaredWorkspaces();
         const allowed = new Set();
         for (const row of declared) {
-            if (row.feature !== undefined) {
-                allowed.add(resolve(row.feature));
-            }
-            if (row.subtask !== undefined) {
-                allowed.add(resolve(row.subtask));
-            }
+            allowed.add(resolve(row.path));
         }
         await destroyOrphans(workspaceRoot, allowed);
         for (const row of declared) {
@@ -234,61 +309,56 @@ export function openConductor(options) {
         if (!got.ok) {
             return;
         }
-        const feature = got.aggregate.workspaces?.feature;
-        const subtask = got.aggregate.workspaces?.subtask;
-        if (subtask !== undefined) {
-            await destroy(subtask);
-        }
-        if (feature !== undefined) {
-            await destroy(feature);
+        if (got.aggregate.workspace !== undefined) {
+            await destroy(got.aggregate.workspace);
         }
-        await ledger.clearWorkspace({ key, feature: true, subtask: true });
+        await ledger.clearWorkspace(key);
     }
-    async function ensureFeatureIsolated(key) {
+    /**
+     * Make the Ticket's workspace from nothing: a unit that starts, starts from
+     * zero, so what an earlier pass left is destroyed first. No lease is held
+     * yet: a failure here costs no Attempt, and the next pass makes it again.
+     */
+    async function isolateFresh(key) {
         const got = await ledger.get(key);
         if (!got.ok) {
             return refused("not-found");
         }
-        const child = declaredFeaturePath(workspaceRoot, key, got.aggregate);
-        if (got.aggregate.workspaces?.feature === undefined) {
-            const declared = await ledger.declareWorkspace({ key, feature: child });
-            const failure = fromLedger(declared);
-            if (failure !== undefined) {
-                return failure;
-            }
+        const workspace = declaredTicketPath(workspaceRoot, key, got.aggregate);
+        if (existsSync(workspace)) {
+            await destroy(workspace);
         }
-        let fresh = false;
-        if (!existsSync(child)) {
-            if (got.aggregate.submission !== undefined) {
-                // The Authority is holding a Submission built from a workspace that is no
-                // longer here. Isolating again would rebuild the feature from the work
-                // line and publish it over that Submission, which would drop whatever the
-                // Authority has already been shown. That is a human's call, not this
-                // loop's.
-                const escalated = await freeze(key, { kind: "submitted" });
-                return escalated;
+        const declared = await ledger.declareWorkspace({ key, path: workspace });
+        const declareFail = fromLedger(declared);
+        if (declareFail !== undefined) {
+            return declareFail;
+        }
+        // Cut from the line as it is now, with nobody moving it meanwhile.
+        const target = targetOf(got.aggregate);
+        const cut = await onLine(async () => {
+            if (!(await refreshLine(target)).ok) {
+                return undefined;
             }
-            const isolated = await transformers.isolate({
+            return await transformers.isolate({
                 id: key,
                 context: key,
                 parent: workLineStable,
-                child,
+                child: workspace,
                 durationMs,
             });
-            if (isolated.outcome === "interrupted") {
-                return refused("interrupted");
-            }
-            if (isolated.outcome !== "isolated") {
-                return refused(isolated.outcome === "invalid-invocation" ? "transformer-invalid" : "isolate-failed");
-            }
-            fresh = true;
-            warmed.delete(key);
+        });
+        if (cut === undefined) {
+            return refused("line-refresh-failed");
         }
-        if (warm !== undefined && (fresh || !warmed.has(key))) {
-            const prepared = await warm.prepare({
-                workspace: child,
-                durationMs: warm.durationMs,
-            });
+        const isolated = cut;
+        if (isolated.outcome === "interrupted") {
+            return refused("interrupted");
+        }
+        if (isolated.outcome !== "isolated") {
+            return refused(isolated.outcome === "invalid-invocation" ? "transformer-invalid" : "isolate-failed");
+        }
+        if (warm !== undefined) {
+            const prepared = await warm.prepare({ workspace, durationMs: warm.durationMs });
             if (prepared.outcome === "interrupted") {
                 return refused("interrupted");
             }
@@ -298,120 +368,146 @@ export function openConductor(options) {
             if (prepared.outcome !== "warmed") {
                 return refused("warm-failed");
             }
-            warmed.add(key);
         }
         return undefined;
     }
-    async function doPlan(key) {
-        const got = await ledger.get(key);
-        if (!got.ok) {
-            return refused("not-found");
-        }
-        if (got.aggregate.state !== "planning") {
-            return undefined;
-        }
-        const broken = await transformers.breakDown({
-            featureJson: featureJsonOf(got.aggregate.intention),
+    /**
+     * The tests of the Task, before its code.
+     *
+     * Their own agent writes them in the Ticket's workspace and their own Gates
+     * judge them (they must fail, for the right reason). What they wrote is then
+     * committed — a checkpoint, by folding the workspace into itself, which the
+     * Integration does by committing what is loose — so that the producer's work is
+     * what differs from it afterwards, and its Gates can see whether a test was
+     * touched.
+     *
+     * `undefined` when the code may be written; otherwise the result that ends the
+     * pass. Nothing of this is an Attempt of the unit: a pass that fails here is a
+     * Task whose tests could not be written, and a person looks.
+     */
+    async function writeTestsFirst(key, aggregate, workspace) {
+        const written = await transformers.implement({
+            id: `${key}:tests`,
+            context: key,
+            stage: "tests",
+            produce: true,
+            intention: aggregate.intention.intention,
+            workspace,
         });
-        if (broken.outcome === "refused") {
-            const recorded = await ledger.refusePlan({
-                key,
-                code: broken.code,
-                reason: broken.reason,
-            });
-            const failure = fromLedger(recorded);
-            if (failure !== undefined) {
-                return failure;
-            }
-            return { outcome: "escalated", key };
-        }
-        if (broken.outcome === "interrupted") {
-            return refused("interrupted");
-        }
-        if (broken.outcome === "unavailable") {
-            return refused("unavailable");
+        if (written.outcome === "interrupted") {
+            const failure = await releaseHeldAfterInterrupt(key);
+            return failure ?? refused("interrupted");
         }
-        if (broken.outcome !== "planned") {
+        if (written.outcome === "invalid-invocation") {
             return refused("transformer-invalid");
         }
-        const recorded = await ledger.recordPlan({
-            key,
-            plannedAt: broken.plannedAt,
-            subtasks: broken.subtasks,
+        if (written.outcome === "escalated") {
+            const why = reasonOfTraces(written.traces);
+            return await freeze(key, {
+                kind: "unit",
+                report: `The tests could not be written first.${why === undefined ? "" : ` ${why}`}`,
+            });
+        }
+        const checkpoint = await transformers.integrate({
+            id: `${key}:tests`,
+            context: key,
+            parent: workspace,
+            child: workspace,
+            durationMs,
+            subject: `Tests: ${subjectOf(aggregate.intention.title ?? aggregate.intention.intention)}`,
         });
-        const recordFail = fromLedger(recorded);
-        if (recordFail !== undefined) {
-            return recordFail;
+        if (checkpoint.outcome === "interrupted") {
+            const failure = await releaseHeldAfterInterrupt(key);
+            return failure ?? refused("interrupted");
         }
-        await observe({ kind: "planned", key });
-        return undefined;
+        if (checkpoint.outcome !== "integrated") {
+            return await freeze(key, {
+                kind: "unit",
+                report: "The tests that were written first could not be committed.",
+            });
+        }
+        // A pass that is stopped from here on does not write them again.
+        const marked = await ledger.markFirstStageDone(key);
+        return fromLedger(marked);
     }
-    async function runOneSubtask(key, subtaskId) {
+    /**
+     * Run the unit: Builder, then the Gates, in the workspace Isolation made.
+     * The result stays loose in the workspace; the Integration in `doIntegrating`
+     * is what takes it up.
+     */
+    async function doRunning(key) {
+        if (paused) {
+            return { outcome: "paused", key };
+        }
         const before = await ledger.get(key);
-        const started = await ledger.startSubtask({ key, subtaskId });
-        const startFail = fromLedger(started);
-        if (startFail !== undefined) {
-            return startFail;
+        if (!before.ok) {
+            return refused("not-found");
         }
-        const child = subtaskWorkspacePath(workspaceRoot, key, subtaskId);
-        // Resume from zero: Isolator refuses an existing Child. A kept one may sit
-        // where an earlier layout put it; it goes too, or its branch stays taken.
-        const kept = before.ok ? before.aggregate.workspaces?.subtask : undefined;
-        for (const path of new Set([child, ...(kept === undefined ? [] : [kept])])) {
-            if (existsSync(path)) {
-                await destroy(path);
-            }
+        if (before.aggregate.state !== "running") {
+            return undefined;
         }
-        const declared = await ledger.declareWorkspace({ key, subtask: child });
-        const declareFail = fromLedger(declared);
-        if (declareFail !== undefined) {
-            return declareFail;
+        if (before.aggregate.bail !== undefined) {
+            // A unit is held: its lease runs out on its own if nobody is on it.
+            return { outcome: "paused", key };
         }
-        const featureNow = await ledger.get(key);
-        const parent = declaredFeaturePath(workspaceRoot, key, featureNow.ok ? featureNow.aggregate : undefined);
-        const isolated = await transformers.isolate({
-            // Scoped to the feature: a Subtask id is unique inside its plan and
-            // nowhere else, so "A" alone would name every feature's first Subtask.
-            id: `${key}:${subtaskId}`,
-            context: key,
-            parent,
-            child,
-            durationMs,
-        });
-        if (isolated.outcome === "interrupted") {
-            const failure = await releaseHeldAfterInterrupt(key);
-            return failure ?? refused("interrupted");
+        // A pass that was stopped (Mason stopped, or died) leaves its workspace declared: this one
+        // picks it up. A unit that starts with nothing left starts from zero.
+        const resumed = await stillThere(before.aggregate.workspace);
+        if (!resumed) {
+            const isolated = await isolateFresh(key);
+            if (isolated !== undefined) {
+                return isolated;
+            }
         }
-        if (isolated.outcome !== "isolated") {
-            return refused(isolated.outcome === "invalid-invocation" ? "transformer-invalid" : "isolate-failed");
+        if (paused) {
+            return { outcome: "paused", key };
+        }
+        const started = await ledger.startUnit(key);
+        const startFail = fromLedger(started);
+        if (startFail !== undefined) {
+            return startFail;
         }
         const got = await ledger.get(key);
         if (!got.ok) {
             return refused("not-found");
         }
-        const subtask = got.aggregate.plan?.subtasks.find((st) => st.id === subtaskId);
-        if (subtask === undefined) {
-            return refused("not-found");
-        }
+        const unitPath = declaredTicketPath(workspaceRoot, key, got.aggregate);
+        // The tracker can say a ticket has no tests written first: a label, not a line of its text.
+        if (testsFirst &&
+            got.aggregate.intention.no_tests !== true &&
+            got.aggregate.first_stage_done !== true) {
+            const stopped = await writeTestsFirst(key, got.aggregate, unitPath);
+            if (stopped !== undefined) {
+                return stopped;
+            }
+        }
+        // The Attempts the stopped pass finished count, and the next one goes on from them.
+        const earlier = resumed
+            ? got.aggregate.attempts.filter((attempt) => attempt.round === got.aggregate.resumes)
+            : [];
+        const last = earlier[earlier.length - 1]?.trace;
+        const carried = last?.ended === "fail-retryable" ? last : undefined;
+        const report = carried?.report ?? (resumed ? RESUMED_NOTE : undefined);
         const implemented = await transformers.implement({
-            id: subtaskId,
+            id: key,
             context: key,
-            intention: subtask.intention,
-            definitionOfDone: subtask.definition_of_done,
-            workspace: child,
+            intention: got.aggregate.intention.intention,
+            workspace: unitPath,
+            ...(report === undefined ? {} : { report }),
+            ...(carried?.refusedBy === undefined ? {} : { reportFrom: carried.refusedBy }),
+            ...(earlier.length === 0 ? {} : { firstAttempt: earlier.length + 1 }),
         });
         if (implemented.outcome === "interrupted") {
-            const failure = await releaseHeldAfterInterrupt(key);
+            const failure = await releaseHeldAfterInterrupt(key, implemented.traces);
             return failure ?? refused("interrupted");
         }
         if (implemented.outcome === "invalid-invocation") {
             return refused("transformer-invalid");
         }
-        let number = got.aggregate.attempts.filter((a) => a.subtask_id === subtaskId).length + 1;
+        let number = got.aggregate.attempts.length + 1;
         for (const trace of implemented.traces) {
             const recorded = await ledger.recordAttempt({
                 key,
-                subtaskId,
                 number,
                 trace: {
                     ended: trace.ended,
@@ -430,77 +526,17 @@ export function openConductor(options) {
         if (implemented.outcome === "escalated") {
             const why = reasonOfTraces(implemented.traces);
             return await freeze(key, {
-                kind: "subtask",
-                subtaskId,
+                kind: "unit",
                 ...(why === undefined ? {} : { report: why }),
             });
         }
-        const folded = await transformers.integrate({
-            id: subtaskId,
-            context: key,
-            parent,
-            child,
-            durationMs,
-            // What carries the work into the feature says what the work was.
-            subject: foldMessageOf(subtask.intention),
-            mergeSubject: `Merge ${subtaskId} into the feature`,
-        });
-        if (folded.outcome === "interrupted") {
-            const failure = await releaseHeldAfterInterrupt(key);
-            return failure ?? refused("interrupted");
-        }
-        if (folded.outcome === "conflict") {
-            // The unit passed its Gates; what stopped it is the fold, which leaves
-            // no trace of its own. Said here, or the escalation says nothing.
-            return await freeze(key, {
-                kind: "subtask",
-                subtaskId,
-                report: `Folding ${subtaskId} into the feature hit a conflict.`,
-            });
-        }
-        if (folded.outcome !== "integrated") {
-            return refused("transformer-invalid");
-        }
-        const marked = await ledger.markSubtaskIntegrated({ key, subtaskId });
+        const marked = await ledger.markIntegrating(key);
         const markFail = fromLedger(marked);
         if (markFail !== undefined) {
             return markFail;
         }
-        await destroy(child);
-        await ledger.clearWorkspace({ key, subtask: true });
-        const after = await ledger.get(key);
-        if (after.ok && after.aggregate.plan !== undefined) {
-            const subtasks = after.aggregate.plan.subtasks;
-            await observe({
-                kind: "subtask-integrated",
-                key,
-                subtaskId,
-                integrated: subtasks.filter((subtask) => subtask.state === "integrated").length,
-                total: subtasks.length,
-            });
-        }
         return await freezeIfPending(key);
     }
-    async function doRunning(key) {
-        const isolated = await ensureFeatureIsolated(key);
-        if (isolated !== undefined) {
-            return isolated;
-        }
-        while (!paused) {
-            const next = await ledger.nextRunnable(key);
-            if (next === undefined) {
-                break;
-            }
-            const step = await runOneSubtask(key, next);
-            if (step !== undefined) {
-                return step;
-            }
-        }
-        if (paused) {
-            return { outcome: "paused", key };
-        }
-        return undefined;
-    }
     async function doIntegrating(key) {
         if (paused) {
             return { outcome: "paused", key };
@@ -513,122 +549,16 @@ export function openConductor(options) {
         if (!got.ok) {
             return refused("not-found");
         }
-        const featurePath = declaredFeaturePath(workspaceRoot, key, got.aggregate);
-        // A parked refusal is this round's; a Submission's is carried forward on
-        // purpose and may already be repaired. The fresher one wins.
-        const parked = got.aggregate.parked_refusal;
-        const sentBack = parked?.report ?? got.aggregate.submission?.last_report;
-        if (sentBack !== undefined) {
-            // Something refused the last round and said why. That report is the only
-            // reason this stage has to produce: the Subtasks are already validated.
-            //
-            // Before the Integration below, and that order is the whole point. What a
-            // producer leaves is loose in the workspace; the Integration is the only
-            // thing that takes it up. Producing after it means the repair waits for
-            // the next round to be taken up at all, and what goes out meanwhile is the
-            // state that was already refused — the same refusal comes back, and the
-            // budget empties on the delay.
-            const refusedBy = parked?.refused_by ?? got.aggregate.submission?.last_refused_by;
-            const remade = await transformers.implement({
-                id: `${key}:assembly`,
-                context: key,
-                stage: "assembly",
-                produce: true,
-                intention: got.aggregate.intention.intention,
-                workspace: featurePath,
-                report: sentBack,
-                ...(refusedBy === undefined ? {} : { reportFrom: refusedBy }),
-            });
-            if (remade.outcome === "interrupted") {
-                return refused("interrupted");
-            }
-            if (remade.outcome === "invalid-invocation") {
-                return refused("transformer-invalid");
-            }
-            if (remade.outcome === "escalated") {
-                // The whole, not one of its parts: naming a Subtask here sends a reader
-                // to look at work that did not fail.
-                const why = reasonOfTraces(remade.traces);
-                return await freeze(key, {
-                    kind: "assembly",
-                    ...(why === undefined ? {} : { report: why }),
-                });
-            }
-        }
-        const aligned = await transformers.integrate({
-            id: `${key}:align`,
-            context: key,
-            parent: featurePath,
-            child: workLineStable,
-            durationMs,
-            // What is loose in the feature workspace here is a repair, if anything.
-            subject: sentBack === undefined
-                ? `Align with ${workLineTarget || "the work line"}`
-                : "Repair after it was refused",
-            mergeSubject: `Merge ${workLineTarget || "the work line"} into the feature`,
-        });
-        if (aligned.outcome === "interrupted") {
-            return refused("interrupted");
-        }
-        if (aligned.outcome === "conflict") {
-            return refused("align-conflict");
-        }
-        if (aligned.outcome !== "integrated") {
-            return refused("transformer-invalid");
-        }
-        if (paused) {
-            return { outcome: "paused", key };
-        }
-        if (assemblyValidate) {
-            const validated = await transformers.implement({
-                id: `${key}:validate`,
-                context: key,
-                stage: "assembly",
-                validate: true,
-                intention: got.aggregate.intention.intention,
-                workspace: featurePath,
-            });
-            if (validated.outcome === "interrupted") {
-                return refused("interrupted");
-            }
-            if (validated.outcome === "invalid-invocation") {
-                return refused("transformer-invalid");
-            }
-            if (validated.outcome === "escalated") {
-                const last = validated.traces.at(-1);
-                const report = last?.report ?? "The assembled feature was refused, with no reason given.";
-                const spent = (got.aggregate.submission?.refusals ?? 0) + (got.aggregate.parked_refusals ?? 0);
-                const canRepair = assemblyFixDeclared && last?.ended !== "fail-blocking" && spent + 1 < maxRefusals;
-                if (!canRepair) {
-                    return await freeze(key, {
-                        kind: "assembly",
-                        report: last?.refusedBy === undefined ? report : `${last.refusedBy}: ${report}`,
-                    });
-                }
-                const recorded = await ledger.recordParkedRefusal({
-                    key,
-                    report,
-                    ...(last?.refusedBy === undefined ? {} : { refusedBy: last.refusedBy }),
-                });
-                const failure = fromLedger(recorded);
-                if (failure !== undefined) {
-                    return failure;
-                }
-                // Repair is on its way: do not offer, or judge, work that is already
-                // known to need it.
-                return { outcome: "paused", key };
-            }
-            const cleared = await ledger.clearParkedRefusal(key);
-            const clearFail = fromLedger(cleared);
-            if (clearFail !== undefined) {
-                return clearFail;
-            }
+        const unit = unitOf(key, got.aggregate);
+        const prepared = await delivery.prepare(unit, ticketStore(key));
+        if (prepared !== "ready") {
+            return prepared;
         }
         if (authority === undefined) {
             // Nobody outside will look at it, so the Project's own sequence is the
-            // only judgement the assembled feature gets. Skipping it here would let
+            // only judgement the assembled ticket gets. Skipping it here would let
             // work into the work line that nothing ever judged as a whole.
-            const judged = await judge(key, got.aggregate);
+            const judged = await delivery.judge(unit);
             if (judged.outcome === "interrupted") {
                 return refused("interrupted");
             }
@@ -648,9 +578,9 @@ export function openConductor(options) {
         return await offer(key, got.aggregate);
     }
     /**
-     * Put the assembled feature in front of the Authority.
+     * Put the assembled ticket in front of the Authority.
      *
-     * A feature already submitted is offered again rather than a second time:
+     * A ticket already submitted is offered again rather than a second time:
      * the work was published to the same place, so the Authority is judging the
      * same Submission with new content.
      */
@@ -660,16 +590,14 @@ export function openConductor(options) {
         }
         const title = aggregate.intention.title;
         const intention = aggregate.intention.intention;
-        const steps = aggregate.plan?.subtasks.map((subtask) => subtask.intention) ?? [];
         const submitted = await authority.submit({
             key,
             project: aggregate.intention.project,
             ref: key,
-            target: workLineTarget,
-            workspace: declaredFeaturePath(workspaceRoot, key, aggregate),
+            target: targetOf(aggregate),
+            workspace: declaredTicketPath(workspaceRoot, key, aggregate),
             ...(title === undefined ? {} : { title }),
             ...(intention === undefined ? {} : { intention }),
-            ...(steps.length === 0 ? {} : { steps }),
         });
         if (submitted.outcome === "unavailable") {
             // Nothing is lost: the state still says integrating, and the next pass
@@ -687,72 +615,15 @@ export function openConductor(options) {
         await observe({ kind: "submitted", key, reference: submitted.reference });
         return { outcome: "paused", key };
     }
-    /**
-     * Judge the assembled feature with the Project's Gate sequence for it.
-     *
-     * Nothing is produced: the work is done, and this pass only decides whether it
-     * may enter the work line. A Gate that reads an outside answer belongs in that
-     * sequence like any other — it says ok or not, and it does not act.
-     */
-    async function judge(key, aggregate) {
-        return await transformers.implement({
-            id: `${key}:judgement`,
-            context: key,
-            stage: "assembly",
-            produce: false,
-            intention: aggregate.intention.intention,
-            workspace: declaredFeaturePath(workspaceRoot, key, aggregate),
-        });
-    }
     async function doSubmitted(key) {
         const got = await ledger.get(key);
         if (!got.ok) {
             return refused("not-found");
         }
-        const submission = got.aggregate.submission;
-        if (authority === undefined || submission === undefined) {
-            return refused("transformer-invalid");
-        }
-        const featurePath = declaredFeaturePath(workspaceRoot, key, got.aggregate);
-        const judged = await judge(key, got.aggregate);
-        if (judged.outcome === "interrupted") {
-            return refused("interrupted");
-        }
-        if (judged.outcome === "invalid-invocation") {
-            return refused("transformer-invalid");
-        }
-        if (judged.outcome === "escalated") {
-            const last = judged.traces.at(-1);
-            const report = last?.report ?? "The Submission was refused, with no reason given.";
-            // A blocking refusal is not something another round repairs, and neither
-            // is one more refusal than the budget allows.
-            if (last?.ended === "fail-blocking" || submission.refusals + 1 >= maxRefusals) {
-                // The refusal that stopped it is never recorded as one — this is the
-                // only place it can be kept for the person who reads the escalation.
-                return await freeze(key, {
-                    kind: "submitted",
-                    report: last?.refusedBy === undefined ? report : `${last.refusedBy}: ${report}`,
-                });
-            }
-            const recorded = await ledger.recordRefusal({
-                key,
-                report,
-                ...(last?.refusedBy === undefined ? {} : { refusedBy: last.refusedBy }),
-            });
-            const failure = fromLedger(recorded);
-            if (failure !== undefined) {
-                return failure;
-            }
-            // Back to where the work is made. The next pass produces with that report
-            // in hand and publishes to the same place.
-            return { outcome: "paused", key };
-        }
-        const folded = await authority.fold({ reference: submission.reference });
-        if (folded.outcome === "unavailable") {
-            return { outcome: "paused", key };
-        }
-        if (folded.outcome === "conflict") {
-            return await freeze(key, { kind: "submitted" });
+        const ticketPath = declaredTicketPath(workspaceRoot, key, got.aggregate);
+        const settled = await delivery.settle(unitOf(key, got.aggregate), ticketStore(key));
+        if (!("folded" in settled)) {
+            return settled;
         }
         // The Authority folded it. The work line moved; this system's copy has not,
         // and whoever wired the Authority is the one that brings it up to date.
@@ -761,30 +632,30 @@ export function openConductor(options) {
         if (mergingFailure !== undefined) {
             return mergingFailure;
         }
-        const done = await ledger.markDone(key, { reference: folded.reference });
+        const done = await ledger.markDone(key, { reference: settled.reference });
         const doneFailure = fromLedger(done);
         if (doneFailure !== undefined) {
             return doneFailure;
         }
-        await destroy(featurePath);
-        await ledger.clearWorkspace({ key, feature: true, subtask: true });
+        await destroy(ticketPath);
+        await ledger.clearWorkspace(key);
         return { outcome: "done", key };
     }
     async function doMerging(key) {
         const got = await ledger.get(key);
-        const featurePath = declaredFeaturePath(workspaceRoot, key, got.ok ? got.aggregate : undefined);
+        const ticketPath = declaredTicketPath(workspaceRoot, key, got.ok ? got.aggregate : undefined);
         const title = got.ok
             ? (got.aggregate.intention.title ?? got.aggregate.intention.intention)
             : key;
-        const folded = await transformers.integrate({
+        const folded = await onLine(async () => await transformers.integrate({
             id: key,
             context: key,
             parent: workLineStable,
-            child: featurePath,
+            child: ticketPath,
             durationMs,
             subject: foldMessageOf(title),
             mergeSubject: `Merge ${subjectOf(title)}`,
-        });
+        }));
         if (folded.outcome === "interrupted") {
             return refused("interrupted");
         }
@@ -799,15 +670,30 @@ export function openConductor(options) {
         if (failure !== undefined) {
             return failure;
         }
-        await destroy(featurePath);
-        await ledger.clearWorkspace({ key, feature: true, subtask: true });
+        await destroy(ticketPath);
+        await ledger.clearWorkspace(key);
         return { outcome: "done", key };
     }
-    async function drive(key) {
-        const planResult = await doPlan(key);
-        if (planResult !== undefined) {
-            return planResult;
+    /**
+     * The assembled work is in the workspace and nowhere else. When it is gone,
+     * making it again from the work line would drop what was made, and when the
+     * Authority holds a Submission built from it, publish over what it was
+     * shown. Either is a human's call, not this loop's.
+     */
+    async function workspaceGone(key) {
+        const got = await ledger.get(key);
+        if (!got.ok) {
+            return refused("not-found");
+        }
+        if (existsSync(declaredTicketPath(workspaceRoot, key, got.aggregate))) {
+            return undefined;
         }
+        return await freeze(key, {
+            kind: got.aggregate.submission === undefined ? "assembly" : "submitted",
+            report: "The workspace the work was assembled in is gone.",
+        });
+    }
+    async function drive(key) {
         const runningResult = await doRunning(key);
         if (runningResult !== undefined) {
             return runningResult;
@@ -822,6 +708,13 @@ export function openConductor(options) {
         if (got.aggregate.state === "running") {
             return { outcome: "paused", key };
         }
+        if (got.aggregate.state === "done") {
+            return { outcome: "done", key };
+        }
+        const gone = await workspaceGone(key);
+        if (gone !== undefined) {
+            return gone;
+        }
         if (got.aggregate.state === "integrating") {
             const integratingResult = await doIntegrating(key);
             if (integratingResult !== undefined) {
@@ -868,7 +761,7 @@ export function openConductor(options) {
             if (paused) {
                 return { outcome: "paused" };
             }
-            const claimed = await ledger.claim(project);
+            const claimed = await ledger.claim(project, maxParallel);
             if (!claimed.ok) {
                 const failure = fromLedger(claimed);
                 return failure ?? refused("illegal-transition");
@@ -878,6 +771,19 @@ export function openConductor(options) {
             }
             return await drive(claimed.key);
         },
+        async claimNext(project) {
+            if (paused || !(await isDirectory(workLineStable))) {
+                return undefined;
+            }
+            const claimed = await ledger.claim(project, maxParallel);
+            return claimed.ok && "key" in claimed ? { key: claimed.key } : undefined;
+        },
+        async runTicket(key) {
+            if (!(await isDirectory(workLineStable))) {
+                return refused("stable-missing");
+            }
+            return await drive(key);
+        },
         async cancel(key) {
             const cancelled = await ledger.cancel(key);
             if (cancelled.ok) {
@@ -887,10 +793,12 @@ export function openConductor(options) {
         },
         async release(key) {
             const before = await ledger.get(key);
-            const child = before.ok ? before.aggregate.workspaces?.subtask : undefined;
+            const child = before.ok ? before.aggregate.workspace : undefined;
             const released = await ledger.releaseBail(key);
             if (released.ok && child !== undefined) {
+                // The way to start a unit over: what a stopped pass left is dropped, not picked up.
                 await destroy(child);
+                await ledger.clearWorkspace(key);
             }
             return released;
         },