@bluewombat/conductor 0.1.0

package/dist/run/open-conductor.js

@@ -0,0 +1,775 @@
+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";
+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();
+    }
+    catch {
+        return false;
+    }
+}
+async function destroy(path) {
+    await rm(path, { recursive: true, force: true });
+}
+async function destroyOrphans(workspaceRoot, allowed) {
+    if (!(await isDirectory(workspaceRoot))) {
+        return;
+    }
+    const top = await readdir(workspaceRoot, { withFileTypes: true });
+    for (const entry of top) {
+        const keyDir = resolve(join(workspaceRoot, entry.name));
+        if (!entry.isDirectory()) {
+            await destroy(keyDir);
+            continue;
+        }
+        const keepsKeyDir = [...allowed].some((path) => path === keyDir || path.startsWith(`${keyDir}/`));
+        if (!keepsKeyDir) {
+            await destroy(keyDir);
+            continue;
+        }
+        const inner = await readdir(keyDir, { withFileTypes: true });
+        for (const child of inner) {
+            const childPath = resolve(join(keyDir, child.name));
+            if (!allowed.has(childPath)) {
+                await destroy(childPath);
+            }
+        }
+    }
+}
+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.");
+    }
+    if (resolve(options.workLineStable) === resolve(options.workspaceRoot)) {
+        throw new Error("Conductor workspaceRoot must not be the WorkLineStable path.");
+    }
+    const ledger = options.ledger;
+    const observe = async (moment) => {
+        try {
+            await options.observe?.(moment);
+        }
+        catch {
+            // The watcher's failure is not the work's.
+        }
+    };
+    const transformers = options.transformers;
+    const workLineStable = resolve(options.workLineStable);
+    const workspaceRoot = resolve(options.workspaceRoot);
+    const durationMs = options.transformerDurationMs ?? DEFAULT_TRANSFORMER_DURATION_MS;
+    const authority = options.authority;
+    const workLineTarget = options.workLineTarget ?? "";
+    const maxRefusals = options.maxRefusals ?? DEFAULT_MAX_REFUSALS;
+    let paused = 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;
+        }
+        if (result.code === "persist-failed") {
+            return refused("persist-failed");
+        }
+        if (result.code === "point-of-no-return" ||
+            result.code === "project-busy" ||
+            result.code === "not-found" ||
+            result.code === "illegal-transition") {
+            return refused(result.code);
+        }
+        return refused("illegal-transition");
+    };
+    /**
+     * Freeze the Feature 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.`
+            : undefined;
+        const report = [input.report, pending]
+            .filter((part) => part !== undefined && part.length > 0)
+            .join(" ");
+        const escalated = await ledger.escalate({
+            key,
+            kind: input.kind,
+            ...(input.subtaskId === undefined ? {} : { subtaskId: input.subtaskId }),
+            ...(report.length === 0 ? {} : { report }),
+        });
+        const failure = fromLedger(escalated);
+        if (failure !== undefined) {
+            return failure;
+        }
+        return { outcome: "escalated", key };
+    }
+    async function freezeIfPending(key) {
+        const got = await ledger.get(key);
+        if (!got.ok || got.aggregate.pending_fingerprint === undefined) {
+            return undefined;
+        }
+        return await freeze(key, { kind: "plan" });
+    }
+    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);
+            }
+        }
+    }
+    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));
+            }
+        }
+        await destroyOrphans(workspaceRoot, allowed);
+        for (const row of declared) {
+            await expireIfHeld(row.key);
+        }
+        const active = await ledger.activeOn(project);
+        if (active !== undefined) {
+            await expireIfHeld(active.key);
+        }
+    }
+    async function destroyDeclared(key) {
+        const got = await ledger.get(key);
+        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);
+        }
+        await ledger.clearWorkspace({ key, feature: true, subtask: true });
+    }
+    async function ensureFeatureIsolated(key) {
+        const child = featureWorkspacePath(workspaceRoot, key);
+        const got = await ledger.get(key);
+        if (!got.ok) {
+            return refused("not-found");
+        }
+        if (got.aggregate.workspaces?.feature === undefined) {
+            const declared = await ledger.declareWorkspace({ key, feature: child });
+            const failure = fromLedger(declared);
+            if (failure !== undefined) {
+                return failure;
+            }
+        }
+        if (existsSync(child)) {
+            return undefined;
+        }
+        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,
+            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");
+        }
+        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),
+        });
+        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 (broken.outcome !== "planned") {
+            return refused("transformer-invalid");
+        }
+        const recorded = await ledger.recordPlan({
+            key,
+            plannedAt: broken.plannedAt,
+            subtasks: broken.subtasks,
+        });
+        const recordFail = fromLedger(recorded);
+        if (recordFail !== undefined) {
+            return recordFail;
+        }
+        await observe({ kind: "planned", key });
+        return undefined;
+    }
+    async function runOneSubtask(key, subtaskId) {
+        const started = await ledger.startSubtask({ key, subtaskId });
+        const startFail = fromLedger(started);
+        if (startFail !== undefined) {
+            return startFail;
+        }
+        const child = subtaskWorkspacePath(workspaceRoot, key, subtaskId);
+        if (existsSync(child)) {
+            // Resume from zero: Isolator refuses an existing Child.
+            await destroy(child);
+        }
+        const declared = await ledger.declareWorkspace({ key, subtask: child });
+        const declareFail = fromLedger(declared);
+        if (declareFail !== undefined) {
+            return declareFail;
+        }
+        const parent = featureWorkspacePath(workspaceRoot, key);
+        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}`,
+            parent,
+            child,
+            durationMs,
+        });
+        if (isolated.outcome === "interrupted") {
+            return 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,
+            context: key,
+            intention: subtask.intention,
+            definitionOfDone: subtask.definition_of_done,
+            workspace: child,
+        });
+        if (implemented.outcome === "interrupted") {
+            return refused("interrupted");
+        }
+        if (implemented.outcome === "invalid-invocation") {
+            return refused("transformer-invalid");
+        }
+        let number = got.aggregate.attempts.filter((a) => a.subtask_id === subtaskId).length + 1;
+        for (const trace of implemented.traces) {
+            const recorded = await ledger.recordAttempt({
+                key,
+                subtaskId,
+                number,
+                trace: {
+                    ended: trace.ended,
+                    ...(trace.report === undefined || trace.report.length === 0
+                        ? {}
+                        : { report: trace.report }),
+                    ...(trace.refusedBy === undefined ? {} : { refusedBy: trace.refusedBy }),
+                },
+            });
+            const failure = fromLedger(recorded);
+            if (failure !== undefined) {
+                return failure;
+            }
+            number += 1;
+        }
+        if (implemented.outcome === "escalated") {
+            const why = reasonOfTraces(implemented.traces);
+            return await freeze(key, {
+                kind: "subtask",
+                subtaskId,
+                ...(why === undefined ? {} : { report: why }),
+            });
+        }
+        const folded = await transformers.integrate({
+            id: subtaskId,
+            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") {
+            return 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 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 };
+        }
+        const pending = await freezeIfPending(key);
+        if (pending !== undefined) {
+            return pending;
+        }
+        const featurePath = featureWorkspacePath(workspaceRoot, key);
+        const got = await ledger.get(key);
+        if (!got.ok) {
+            return refused("not-found");
+        }
+        const sentBack = 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 remade = await transformers.implement({
+                id: `${key}:assembly`,
+                context: key,
+                stage: "assembly",
+                produce: true,
+                intention: got.aggregate.intention.intention,
+                workspace: featurePath,
+                report: sentBack,
+                ...(got.aggregate.submission?.last_refused_by === undefined
+                    ? {}
+                    : { reportFrom: got.aggregate.submission.last_refused_by }),
+            });
+            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`,
+            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 the Submission 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 (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
+            // work into the work line that nothing ever judged as a whole.
+            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 why = reasonOfTraces(judged.traces);
+                return await freeze(key, {
+                    kind: "assembly",
+                    ...(why === undefined ? {} : { report: why }),
+                });
+            }
+            const merging = await ledger.markMerging(key);
+            return fromLedger(merging);
+        }
+        return await offer(key, got.aggregate);
+    }
+    /**
+     * Put the assembled feature in front of the Authority.
+     *
+     * A feature 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.
+     */
+    async function offer(key, aggregate) {
+        if (authority === undefined) {
+            return refused("transformer-invalid");
+        }
+        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,
+            ...(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
+            // offers it again.
+            return { outcome: "paused", key };
+        }
+        if (submitted.outcome === "refused") {
+            return await freeze(key, { kind: "submitted" });
+        }
+        const marked = await ledger.markSubmitted({ key, reference: submitted.reference });
+        const failure = fromLedger(marked);
+        if (failure !== undefined) {
+            return failure;
+        }
+        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: featureWorkspacePath(workspaceRoot, key),
+        });
+    }
+    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 = featureWorkspacePath(workspaceRoot, key);
+        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" });
+        }
+        // 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.
+        const merging = await ledger.markMerging(key);
+        const mergingFailure = fromLedger(merging);
+        if (mergingFailure !== undefined) {
+            return mergingFailure;
+        }
+        const done = await ledger.markDone(key, { reference: folded.reference });
+        const doneFailure = fromLedger(done);
+        if (doneFailure !== undefined) {
+            return doneFailure;
+        }
+        await destroy(featurePath);
+        await ledger.clearWorkspace({ key, feature: true, subtask: true });
+        return { outcome: "done", key };
+    }
+    async function doMerging(key) {
+        const featurePath = featureWorkspacePath(workspaceRoot, key);
+        const got = await ledger.get(key);
+        const title = got.ok
+            ? (got.aggregate.intention.title ?? got.aggregate.intention.intention)
+            : key;
+        const folded = await transformers.integrate({
+            id: key,
+            parent: workLineStable,
+            child: featurePath,
+            durationMs,
+            subject: foldMessageOf(title),
+            mergeSubject: `Merge ${subjectOf(title)}`,
+        });
+        if (folded.outcome === "interrupted") {
+            return refused("interrupted");
+        }
+        if (folded.outcome === "conflict") {
+            return await freeze(key, { kind: "merging" });
+        }
+        if (folded.outcome !== "integrated") {
+            return refused("transformer-invalid");
+        }
+        const done = await ledger.markDone(key);
+        const failure = fromLedger(done);
+        if (failure !== undefined) {
+            return failure;
+        }
+        await destroy(featurePath);
+        await ledger.clearWorkspace({ key, feature: true, subtask: true });
+        return { outcome: "done", key };
+    }
+    async function drive(key) {
+        const planResult = await doPlan(key);
+        if (planResult !== undefined) {
+            return planResult;
+        }
+        const runningResult = await doRunning(key);
+        if (runningResult !== undefined) {
+            return runningResult;
+        }
+        const got = await ledger.get(key);
+        if (!got.ok) {
+            return refused("not-found");
+        }
+        if (got.aggregate.state === "escalated") {
+            return { outcome: "escalated", key };
+        }
+        if (got.aggregate.state === "running") {
+            return { outcome: "paused", key };
+        }
+        if (got.aggregate.state === "integrating") {
+            const integratingResult = await doIntegrating(key);
+            if (integratingResult !== undefined) {
+                return integratingResult;
+            }
+        }
+        const after = await ledger.get(key);
+        if (!after.ok) {
+            return refused("not-found");
+        }
+        if (after.aggregate.state === "submitted") {
+            return await doSubmitted(key);
+        }
+        if (after.aggregate.state === "merging") {
+            return await doMerging(key);
+        }
+        if (after.aggregate.state === "done") {
+            return { outcome: "done", key };
+        }
+        if (after.aggregate.state === "escalated") {
+            return { outcome: "escalated", key };
+        }
+        return { outcome: "paused", key };
+    }
+    return {
+        async reconcile(project) {
+            await reconcile(project);
+        },
+        pause() {
+            paused = true;
+        },
+        resume() {
+            paused = false;
+        },
+        async runProject(project) {
+            if (!(await isDirectory(workLineStable))) {
+                return refused("stable-missing");
+            }
+            await reconcile(project);
+            const active = await ledger.activeOn(project);
+            if (active !== undefined) {
+                return await drive(active.key);
+            }
+            if (paused) {
+                return { outcome: "paused" };
+            }
+            const claimed = await ledger.claim(project);
+            if (!claimed.ok) {
+                const failure = fromLedger(claimed);
+                return failure ?? refused("illegal-transition");
+            }
+            if ("empty" in claimed) {
+                return { outcome: "idle" };
+            }
+            return await drive(claimed.key);
+        },
+        async cancel(key) {
+            const cancelled = await ledger.cancel(key);
+            if (cancelled.ok) {
+                await destroyDeclared(key);
+            }
+            return cancelled;
+        },
+    };
+}
+//# sourceMappingURL=open-conductor.js.map