@bluewombat/conductor 0.7.0 → 0.9.0

package/dist/run/open-conductor.js

@@ -1,19 +1,9 @@
 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 { ticketWorkspacePath } from "./paths.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();
@@ -26,13 +16,12 @@ async function destroy(path) {
     await rm(path, { recursive: true, force: true });
 }
 /**
- * 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);
 }
 async function destroyOrphans(workspaceRoot, allowed) {
     if (!(await isDirectory(workspaceRoot))) {
@@ -113,12 +102,12 @@ 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 warm = options.warm;
-    /** Features whose warm already succeeded in this Conductor instance. */
-    const warmed = new Set();
     let paused = false;
     const refused = (code) => ({
         outcome: "refused",
@@ -149,13 +138,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 +152,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,24 +165,23 @@ 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" });
     }
     async function expireIfHeld(key) {
+        const before = await ledger.get(key);
+        const held = before.ok && before.aggregate.state === "running" ? before.aggregate.workspace : undefined;
         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);
-            }
+        if (expired.ok && held !== undefined) {
+            await destroy(held);
         }
     }
     /**
-     * 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.
      */
     async function releaseHeldAfterInterrupt(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) {
             if (released.code === "persist-failed") {
@@ -213,12 +200,7 @@ export function openConductor(options) {
         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 +216,45 @@ 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 (got.aggregate.workspace !== undefined) {
+            await destroy(got.aggregate.workspace);
         }
-        if (feature !== undefined) {
-            await destroy(feature);
-        }
-        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 isolated = await transformers.isolate({
-                id: key,
-                context: key,
-                parent: workLineStable,
-                child,
-                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);
+        const declared = await ledger.declareWorkspace({ key, path: workspace });
+        const declareFail = fromLedger(declared);
+        if (declareFail !== undefined) {
+            return declareFail;
         }
-        if (warm !== undefined && (fresh || !warmed.has(key))) {
-            const prepared = await warm.prepare({
-                workspace: child,
-                durationMs: warm.durationMs,
-            });
+        const isolated = await transformers.isolate({
+            id: key,
+            context: key,
+            parent: workLineStable,
+            child: workspace,
+            durationMs,
+        });
+        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,107 +264,50 @@ 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) {
+    /**
+     * 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);
+        if (!before.ok) {
             return refused("not-found");
         }
-        if (got.aggregate.state !== "planning") {
+        if (before.aggregate.state !== "running") {
             return undefined;
         }
-        const broken = await transformers.breakDown({
-            featureJson: featureJsonOf(got.aggregate.intention),
-        });
-        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 (before.aggregate.bail !== undefined) {
+            // A unit is held: its lease runs out on its own if nobody is on it.
+            return { outcome: "paused", key };
         }
-        if (broken.outcome !== "planned") {
-            return refused("transformer-invalid");
+        const isolated = await isolateFresh(key);
+        if (isolated !== undefined) {
+            return isolated;
         }
-        const recorded = await ledger.recordPlan({
-            key,
-            plannedAt: broken.plannedAt,
-            subtasks: broken.subtasks,
-        });
-        const recordFail = fromLedger(recorded);
-        if (recordFail !== undefined) {
-            return recordFail;
+        if (paused) {
+            return { outcome: "paused", key };
         }
-        await observe({ kind: "planned", key });
-        return undefined;
-    }
-    async function runOneSubtask(key, subtaskId) {
-        const before = await ledger.get(key);
-        const started = await ledger.startSubtask({ key, subtaskId });
+        const started = await ledger.startUnit(key);
         const startFail = fromLedger(started);
         if (startFail !== undefined) {
             return startFail;
         }
-        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);
-            }
-        }
-        const declared = await ledger.declareWorkspace({ key, subtask: child });
-        const declareFail = fromLedger(declared);
-        if (declareFail !== undefined) {
-            return declareFail;
-        }
-        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");
-        }
-        if (isolated.outcome !== "isolated") {
-            return refused(isolated.outcome === "invalid-invocation" ? "transformer-invalid" : "isolate-failed");
-        }
         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 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: declaredTicketPath(workspaceRoot, key, got.aggregate),
         });
         if (implemented.outcome === "interrupted") {
             const failure = await releaseHeldAfterInterrupt(key);
@@ -407,11 +316,10 @@ export function openConductor(options) {
         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 +338,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,14 +361,14 @@ export function openConductor(options) {
         if (!got.ok) {
             return refused("not-found");
         }
-        const featurePath = declaredFeaturePath(workspaceRoot, key, got.aggregate);
+        const ticketPath = declaredTicketPath(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.
+            // reason this stage has to produce: the unit is 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
@@ -535,7 +383,7 @@ export function openConductor(options) {
                 stage: "assembly",
                 produce: true,
                 intention: got.aggregate.intention.intention,
-                workspace: featurePath,
+                workspace: ticketPath,
                 report: sentBack,
                 ...(refusedBy === undefined ? {} : { reportFrom: refusedBy }),
             });
@@ -546,7 +394,7 @@ export function openConductor(options) {
                 return refused("transformer-invalid");
             }
             if (remade.outcome === "escalated") {
-                // The whole, not one of its parts: naming a Subtask here sends a reader
+                // The assembled work, not the unit: naming the unit here sends a reader
                 // to look at work that did not fail.
                 const why = reasonOfTraces(remade.traces);
                 return await freeze(key, {
@@ -558,14 +406,15 @@ export function openConductor(options) {
         const aligned = await transformers.integrate({
             id: `${key}:align`,
             context: key,
-            parent: featurePath,
+            parent: ticketPath,
             child: workLineStable,
             durationMs,
-            // What is loose in the feature workspace here is a repair, if anything.
+            // What is loose in the workspace here is the work the Builder made, or a
+            // repair of it.
             subject: sentBack === undefined
-                ? `Align with ${workLineTarget || "the work line"}`
+                ? foldMessageOf(got.aggregate.intention.title ?? got.aggregate.intention.intention)
                 : "Repair after it was refused",
-            mergeSubject: `Merge ${workLineTarget || "the work line"} into the feature`,
+            mergeSubject: `Merge ${targetOf(got.aggregate) || "the work line"} into the ticket`,
         });
         if (aligned.outcome === "interrupted") {
             return refused("interrupted");
@@ -586,7 +435,7 @@ export function openConductor(options) {
                 stage: "assembly",
                 validate: true,
                 intention: got.aggregate.intention.intention,
-                workspace: featurePath,
+                workspace: ticketPath,
             });
             if (validated.outcome === "interrupted") {
                 return refused("interrupted");
@@ -596,7 +445,7 @@ export function openConductor(options) {
             }
             if (validated.outcome === "escalated") {
                 const last = validated.traces.at(-1);
-                const report = last?.report ?? "The assembled feature was refused, with no reason given.";
+                const report = last?.report ?? "The assembled ticket 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) {
@@ -626,7 +475,7 @@ export function openConductor(options) {
         }
         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);
             if (judged.outcome === "interrupted") {
@@ -648,9 +497,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 +509,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
@@ -688,7 +535,7 @@ export function openConductor(options) {
         return { outcome: "paused", key };
     }
     /**
-     * Judge the assembled feature with the Project's Gate sequence for it.
+     * Judge the assembled ticket 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
@@ -701,7 +548,7 @@ export function openConductor(options) {
             stage: "assembly",
             produce: false,
             intention: aggregate.intention.intention,
-            workspace: declaredFeaturePath(workspaceRoot, key, aggregate),
+            workspace: declaredTicketPath(workspaceRoot, key, aggregate),
         });
     }
     async function doSubmitted(key) {
@@ -713,7 +560,7 @@ export function openConductor(options) {
         if (authority === undefined || submission === undefined) {
             return refused("transformer-invalid");
         }
-        const featurePath = declaredFeaturePath(workspaceRoot, key, got.aggregate);
+        const ticketPath = declaredTicketPath(workspaceRoot, key, got.aggregate);
         const judged = await judge(key, got.aggregate);
         if (judged.outcome === "interrupted") {
             return refused("interrupted");
@@ -766,13 +613,13 @@ export function openConductor(options) {
         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;
@@ -780,7 +627,7 @@ export function openConductor(options) {
             id: key,
             context: key,
             parent: workLineStable,
-            child: featurePath,
+            child: ticketPath,
             durationMs,
             subject: foldMessageOf(title),
             mergeSubject: `Merge ${subjectOf(title)}`,
@@ -799,15 +646,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 +684,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) {
@@ -887,7 +756,7 @@ 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) {
                 await destroy(child);