@bluewombat/work-ledger 0.8.0 → 0.10.0

package/dist/ledger/open-work-ledger.js

@@ -1,45 +1,58 @@
-import { checkPlan, initialSubtaskState, refreshRunnable } from "./check-plan.js";
+import { isFeatureAggregate, isFeatureSummary } from "../records.js";
+import { openFeatureCommands } from "./feature-commands.js";
+import { refused } from "./results.js";
 const DEFAULT_BAIL_DURATION_MS = 3_600_000;
 const ACTIVE_STATES = new Set([
-    "planning",
     "running",
     "escalated",
     "integrating",
     "submitted",
     "merging",
 ]);
-const IN_FLIGHT = new Set([
-    "planning",
-    "running",
-    "integrating",
-    "submitted",
-]);
-function refused(code) {
-    return { ok: false, code };
-}
-function cloneIntention(feature) {
+const IN_FLIGHT = new Set(["running", "integrating", "submitted"]);
+function cloneIntention(ticket) {
     const intention = {
-        key: feature.key,
-        project: feature.project,
-        fingerprint: feature.fingerprint,
-        priority: feature.priority,
-        intention: feature.intention,
+        key: ticket.key,
+        project: ticket.project,
+        fingerprint: ticket.fingerprint,
+        priority: ticket.priority,
+        intention: ticket.intention,
     };
-    if (feature.title !== undefined) {
-        intention.title = feature.title;
+    if (ticket.title !== undefined) {
+        intention.title = ticket.title;
+    }
+    if (ticket.manager !== undefined) {
+        intention.manager = ticket.manager;
+    }
+    if (ticket.external_id !== undefined) {
+        intention.external_id = ticket.external_id;
+    }
+    if (ticket.source !== undefined) {
+        intention.source = { ...ticket.source };
+    }
+    if (ticket.feature !== undefined) {
+        intention.feature = ticket.feature;
+    }
+    if (ticket.blocked_by !== undefined) {
+        intention.blocked_by = [...ticket.blocked_by];
     }
-    if (feature.manager !== undefined) {
-        intention.manager = feature.manager;
+    if (ticket.line !== undefined) {
+        intention.line = ticket.line;
     }
-    if (feature.external_id !== undefined) {
-        intention.external_id = feature.external_id;
+    if (ticket.no_tests === true) {
+        intention.no_tests = true;
     }
-    if (feature.source !== undefined) {
-        intention.source = { ...feature.source };
+    if (ticket.e2e === true) {
+        intention.e2e = true;
     }
     return intention;
 }
-function pickReceived(summaries, project) {
+/** The Tickets among what the Port lists: a Feature shares the Port, not the queries. */
+function ticketsOf(summaries) {
+    return summaries.filter((summary) => !isFeatureSummary(summary));
+}
+/** Received Tickets of a Project in the order they would start: priority, then age. */
+function receivedOf(summaries, project) {
     const candidates = summaries.filter((s) => s.project === project && s.state === "received");
     candidates.sort((a, b) => {
         if (b.priority !== a.priority) {
@@ -47,38 +60,32 @@ function pickReceived(summaries, project) {
         }
         return a.received_at - b.received_at;
     });
-    return candidates[0];
-}
-function projectIsBusy(summaries, project) {
-    return summaries.some((s) => s.project === project && ACTIVE_STATES.has(s.state));
-}
-function unblocksCount(subtaskId, subtasks) {
-    return subtasks.filter((st) => st.depends_on.includes(subtaskId)).length;
+    return candidates;
 }
-/** Drop a declared Subtask workspace path; keep the feature path when present. */
-function clearSubtaskWorkspace(aggregate) {
-    if (aggregate.workspaces === undefined) {
-        return;
-    }
-    delete aggregate.workspaces.subtask;
-    if (aggregate.workspaces.feature === undefined) {
-        delete aggregate.workspaces;
-    }
+/**
+ * Whether a Project has no room for another Ticket: `limit` of them are
+ * already active. An escalated Ticket is active, so it holds its place until a
+ * person resolves it; with a limit of 1 that is the Project stopping, as ever.
+ */
+function projectIsBusy(summaries, project, limit = 1) {
+    return (summaries.filter((s) => s.project === project && ACTIVE_STATES.has(s.state)).length >= limit);
 }
 /**
- * A held Subtask becomes runnable from zero. Returns whether one was held.
+ * A held unit starts over from zero: its directory is forgotten, the Attempt
+ * it was in is spent, and the lease is gone. Returns whether one was held.
  */
-function releaseRunningSubtask(aggregate) {
-    if (aggregate.plan === undefined) {
+/**
+ * The held unit stops. Its workspace stays declared: it is a directory the ledger knows nothing
+ * of, and what it holds is the next run's to look at. Whoever wants it gone says so (`clearWorkspace`).
+ * `spend`: an unit that ended without recording its Attempts spent one.
+ */
+function releaseRunningUnit(aggregate, spend) {
+    if (aggregate.state !== "running" || aggregate.bail === undefined) {
         return false;
     }
-    const running = aggregate.plan.subtasks.find((st) => st.state === "running");
-    if (running === undefined) {
-        return false;
+    if (spend) {
+        aggregate.attempts_used += 1;
     }
-    running.state = "runnable";
-    aggregate.attempts_used += 1;
-    clearSubtaskWorkspace(aggregate);
     delete aggregate.bail;
     return true;
 }
@@ -86,6 +93,37 @@ export function openWorkLedger(options) {
     const persist = options.persist;
     const now = options.now ?? (() => Date.now());
     const bailDurationMs = options.bailDurationMs ?? DEFAULT_BAIL_DURATION_MS;
+    /** One claim at a time, in the order asked. */
+    let lastClaim = Promise.resolve();
+    const claiming = (job) => {
+        const run = lastClaim.then(job, job);
+        lastClaim = run.catch(() => undefined);
+        return run;
+    };
+    const loadTicket = async (key) => {
+        const found = await persist.load(key);
+        return found === undefined || isFeatureAggregate(found) ? undefined : found;
+    };
+    /** Whether every Ticket this one waits on is `done`. A blocker nobody knows blocks. */
+    const isUnblocked = async (aggregate) => {
+        for (const blocker of aggregate.intention.blocked_by ?? []) {
+            const found = await loadTicket(blocker);
+            if (found?.state !== "done") {
+                return false;
+            }
+        }
+        return true;
+    };
+    /** The first received Ticket of the Project that may start. */
+    const pickReceived = async (summaries, project) => {
+        for (const candidate of receivedOf(summaries, project)) {
+            const loaded = await loadTicket(candidate.key);
+            if (loaded !== undefined && loaded.state === "received" && (await isUnblocked(loaded))) {
+                return loaded;
+            }
+        }
+        return undefined;
+    };
     const write = async (aggregate) => {
         const saved = await persist.save(aggregate.intention.key, aggregate);
         if (!saved.ok) {
@@ -94,22 +132,23 @@ export function openWorkLedger(options) {
         return { ok: true };
     };
     const loadOrRefuse = async (key) => {
-        const found = await persist.load(key);
+        const found = await loadTicket(key);
         if (found === undefined) {
             return refused("not-found");
         }
         return { ok: true, aggregate: structuredClone(found) };
     };
     return {
-        async admit(feature) {
-            const existing = await persist.load(feature.key);
+        async admit(ticket) {
+            const existing = await loadTicket(ticket.key);
             if (existing === undefined) {
                 const aggregate = {
-                    intention: cloneIntention(feature),
+                    intention: cloneIntention(ticket),
                     state: "received",
                     received_at: now(),
                     attempts: [],
                     attempts_used: 0,
+                    resumes: 0,
                 };
                 return await write(aggregate);
             }
@@ -120,24 +159,24 @@ export function openWorkLedger(options) {
                 return refused("illegal-transition");
             }
             if (IN_FLIGHT.has(existing.state)) {
-                if (feature.fingerprint === existing.intention.fingerprint ||
-                    feature.fingerprint === existing.pending_fingerprint) {
+                if (ticket.fingerprint === existing.intention.fingerprint ||
+                    ticket.fingerprint === existing.pending_fingerprint) {
                     // Same body as the live intention, or as an edit already recorded:
-                    // an echo of a report, not a newer FeatureStandard.
+                    // an echo of a report, not a newer TicketStandard.
                     return { ok: true };
                 }
                 const next = structuredClone(existing);
-                next.pending_fingerprint = feature.fingerprint;
+                next.pending_fingerprint = ticket.fingerprint;
                 return await write(next);
             }
-            if (existing.state === "received" && existing.intention.fingerprint === feature.fingerprint) {
+            if (existing.state === "received" && existing.intention.fingerprint === ticket.fingerprint) {
                 return { ok: true };
             }
             if (existing.state === "received" ||
                 existing.state === "invalid" ||
                 existing.state === "escalated") {
                 const next = structuredClone(existing);
-                next.intention = cloneIntention(feature);
+                next.intention = cloneIntention(ticket);
                 next.state = "received";
                 delete next.invalid;
                 delete next.pending_fingerprint;
@@ -146,7 +185,7 @@ export function openWorkLedger(options) {
             return refused("illegal-transition");
         },
         async recordInvalid(input) {
-            const existing = await persist.load(input.key);
+            const existing = await loadTicket(input.key);
             if (existing !== undefined && (existing.state === "merging" || existing.state === "done")) {
                 return refused("too-late");
             }
@@ -163,6 +202,7 @@ export function openWorkLedger(options) {
                     received_at: now(),
                     attempts: [],
                     attempts_used: 0,
+                    resumes: 0,
                     invalid: { code: input.code, reason: input.reason },
                 };
                 return await write(aggregate);
@@ -180,153 +220,82 @@ export function openWorkLedger(options) {
             delete next.bail;
             return await write(next);
         },
-        async claim(project) {
-            const summaries = await persist.listSummaries();
-            if (projectIsBusy(summaries, project)) {
-                return refused("project-busy");
-            }
-            const picked = pickReceived(summaries, project);
-            if (picked === undefined) {
-                return { ok: true, empty: true };
-            }
-            const loaded = await persist.load(picked.key);
-            if (loaded === undefined || loaded.state !== "received") {
-                return { ok: true, empty: true };
-            }
-            const next = structuredClone(loaded);
-            next.state = "planning";
-            next.bail = { expires_at: now() + bailDurationMs };
-            const saved = await write(next);
-            if (!saved.ok) {
-                return saved;
-            }
-            return { ok: true, key: picked.key };
+        async claim(project, limit = 1) {
+            // Reading the Project and marking the Ticket are two steps; a second
+            // claim between them would take the same Ticket or exceed the limit.
+            return await claiming(async () => {
+                const summaries = ticketsOf(await persist.listSummaries());
+                if (projectIsBusy(summaries, project, limit)) {
+                    return refused("project-busy");
+                }
+                const picked = await pickReceived(summaries, project);
+                if (picked === undefined) {
+                    return { ok: true, empty: true };
+                }
+                const next = structuredClone(picked);
+                next.state = "running";
+                const saved = await write(next);
+                if (!saved.ok) {
+                    return saved;
+                }
+                return { ok: true, key: picked.intention.key };
+            });
         },
-        async recordPlan(input) {
+        async recordAttempt(input) {
             const current = await loadOrRefuse(input.key);
             if (!current.ok) {
                 return current;
             }
             const { aggregate } = current;
-            if (aggregate.state !== "planning") {
+            if (aggregate.state !== "running") {
                 return refused("illegal-transition");
             }
-            if (aggregate.plan !== undefined) {
-                return refused("plan-frozen");
-            }
-            const checked = checkPlan(input.subtasks);
-            if (!checked.ok) {
+            if (input.number !== aggregate.attempts.length + 1) {
                 return refused("illegal-transition");
             }
-            aggregate.plan = {
-                planned_at: input.plannedAt,
-                subtasks: checked.subtasks.map((draft) => ({
-                    ...draft,
-                    state: initialSubtaskState(draft),
-                })),
+            const attempt = {
+                number: input.number,
+                round: aggregate.resumes,
             };
-            aggregate.state = "running";
-            aggregate.bail = { expires_at: now() + bailDurationMs };
-            return await write(aggregate);
-        },
-        async refusePlan(input) {
-            const current = await loadOrRefuse(input.key);
-            if (!current.ok) {
-                return current;
-            }
-            const { aggregate } = current;
-            if (aggregate.state !== "planning") {
-                return refused("illegal-transition");
+            if (input.trace !== undefined) {
+                attempt.trace = input.trace;
             }
-            aggregate.state = "escalated";
-            aggregate.escalation = { kind: "plan", born_in_merging: false };
-            aggregate.invalid = { code: input.code, reason: input.reason };
-            delete aggregate.bail;
+            aggregate.attempts.push(attempt);
+            aggregate.attempts_used += 1;
             return await write(aggregate);
         },
-        async startSubtask(input) {
-            const current = await loadOrRefuse(input.key);
+        async startUnit(key) {
+            const current = await loadOrRefuse(key);
             if (!current.ok) {
                 return current;
             }
             const { aggregate } = current;
-            if (aggregate.plan === undefined) {
-                return refused("plan-not-frozen");
-            }
             if (aggregate.state !== "running") {
                 return refused("illegal-transition");
             }
-            if (aggregate.plan.subtasks.some((st) => st.state === "running")) {
+            if (aggregate.bail !== undefined) {
                 return refused("another-running");
             }
-            const subtask = aggregate.plan.subtasks.find((st) => st.id === input.subtaskId);
-            if (subtask === undefined) {
-                return refused("not-found");
-            }
-            if (subtask.state !== "runnable") {
-                return refused("subtask-not-runnable");
-            }
-            subtask.state = "running";
             aggregate.bail = { expires_at: now() + bailDurationMs };
             return await write(aggregate);
         },
-        async recordAttempt(input) {
-            const current = await loadOrRefuse(input.key);
-            if (!current.ok) {
-                return current;
-            }
-            const { aggregate } = current;
-            if (aggregate.plan === undefined) {
-                return refused("plan-not-frozen");
-            }
-            const subtask = aggregate.plan.subtasks.find((st) => st.id === input.subtaskId);
-            if (subtask === undefined || subtask.state !== "running") {
-                return refused("illegal-transition");
-            }
-            const existing = aggregate.attempts.filter((a) => a.subtask_id === input.subtaskId);
-            const nextNumber = existing.length + 1;
-            if (input.number !== nextNumber) {
-                return refused("illegal-transition");
-            }
-            const attempt = {
-                subtask_id: input.subtaskId,
-                number: input.number,
-                round: aggregate.resumes ?? 0,
-            };
-            if (input.trace !== undefined) {
-                attempt.trace = input.trace;
-            }
-            aggregate.attempts.push(attempt);
-            aggregate.attempts_used += 1;
-            return await write(aggregate);
-        },
-        async markSubtaskIntegrated(input) {
-            const current = await loadOrRefuse(input.key);
+        async markIntegrating(key) {
+            const current = await loadOrRefuse(key);
             if (!current.ok) {
                 return current;
             }
             const { aggregate } = current;
-            if (aggregate.state !== "running" || aggregate.plan === undefined) {
-                return refused("illegal-transition");
-            }
-            const subtask = aggregate.plan.subtasks.find((st) => st.id === input.subtaskId);
-            if (subtask === undefined || subtask.state !== "running") {
+            if (aggregate.state !== "running") {
                 return refused("illegal-transition");
             }
-            subtask.state = "integrated";
-            aggregate.plan.subtasks = refreshRunnable(aggregate.plan.subtasks);
-            const terminal = new Set(["integrated", "cancelled"]);
-            const remaining = aggregate.plan.subtasks.some((st) => !terminal.has(st.state));
-            if (!remaining) {
-                aggregate.state = "integrating";
-            }
+            aggregate.state = "integrating";
             aggregate.bail = { expires_at: now() + bailDurationMs };
             return await write(aggregate);
         },
         /**
-         * The assembled feature is now in front of the Authority.
+         * The assembled ticket is now in front of the Authority.
          *
-         * A second call on an already submitted feature keeps the first reference:
+         * A second call on an already submitted ticket keeps the first reference:
          * the work was pushed again to the same place, and the Authority is judging
          * the same Submission.
          */
@@ -343,7 +312,7 @@ export function openWorkLedger(options) {
             // Rebuilt field by field, so anything added here has to be carried on
             // purpose. What was already sent back is carried: a Submission offered
             // again is the same Submission, and dropping the reason leaves whoever
-            // reads the next escalation with a frozen Feature and no cause.
+            // reads the next escalation with a frozen Ticket and no cause.
             const previous = aggregate.submission;
             aggregate.submission = {
                 reference: previous?.reference ?? input.reference,
@@ -353,13 +322,14 @@ export function openWorkLedger(options) {
                 ...(previous?.last_refused_by === undefined
                     ? {}
                     : { last_refused_by: previous.last_refused_by }),
+                ...(previous?.realigns === undefined ? {} : { realigns: previous.realigns }),
             };
             aggregate.bail = { expires_at: now() + bailDurationMs };
             return await write(aggregate);
         },
         /**
          * The Authority sent the work back. The report is kept for the next Attempt
-         * and the feature returns to integrating, which is where the work is made.
+         * and the ticket returns to integrating, which is where the work is made.
          */
         async recordRefusal(input) {
             const current = await loadOrRefuse(input.key);
@@ -384,6 +354,30 @@ export function openWorkLedger(options) {
             aggregate.bail = { expires_at: now() + bailDurationMs };
             return await write(aggregate);
         },
+        /**
+         * The line the Submission is offered to moved on while it waited. Nothing was
+         * refused, so no report is kept and no fix is owed: the ticket returns to
+         * `integrating`, where the next pass brings it up to date with the line.
+         *
+         * The report of an earlier refusal is dropped on purpose: it was repaired
+         * already, and left in place it would send the next round to repair it again.
+         */
+        async recordRealign(input) {
+            const current = await loadOrRefuse(input.key);
+            if (!current.ok) {
+                return current;
+            }
+            const { aggregate } = current;
+            if (aggregate.state !== "submitted" || aggregate.submission === undefined) {
+                return refused("illegal-transition");
+            }
+            const { last_report: _report, last_refused_by: _by, ...kept } = aggregate.submission;
+            aggregate.submission = { ...kept, realigns: (kept.realigns ?? 0) + 1 };
+            aggregate.state = "integrating";
+            delete aggregate.parked_refusal;
+            aggregate.bail = { expires_at: now() + bailDurationMs };
+            return await write(aggregate);
+        },
         /**
          * `assembly.validate` sent the work back, before any Submission exists to
          * hold the reason. Shares the `maxRefusals` budget with `recordRefusal`.
@@ -404,7 +398,7 @@ export function openWorkLedger(options) {
             aggregate.parked_refusals = (aggregate.parked_refusals ?? 0) + 1;
             return await write(aggregate);
         },
-        /** `assembly.validate` accepted the feature. The counter is the budget spent; it stays. */
+        /** `assembly.validate` accepted the ticket. The counter is the budget spent; it stays. */
         async clearParkedRefusal(key) {
             const current = await loadOrRefuse(key);
             if (!current.ok) {
@@ -444,12 +438,6 @@ export function openWorkLedger(options) {
                 aggregate.integration_reference = input.reference;
             }
             delete aggregate.bail;
-            if (aggregate.workspaces !== undefined) {
-                delete aggregate.workspaces.subtask;
-                if (aggregate.workspaces.feature === undefined) {
-                    delete aggregate.workspaces;
-                }
-            }
             return await write(aggregate);
         },
         async escalate(input) {
@@ -461,13 +449,10 @@ export function openWorkLedger(options) {
             if (aggregate.state === "done" || aggregate.state === "cancelled") {
                 return refused("illegal-transition");
             }
-            if (input.kind === "subtask" && input.subtaskId !== undefined) {
-                const attempts = aggregate.attempts.filter((a) => a.subtask_id === input.subtaskId);
-                if (attempts.length > 0) {
-                    const last = attempts[attempts.length - 1];
-                    if (last?.trace === undefined) {
-                        return refused("missing-trace");
-                    }
+            if (input.kind === "unit") {
+                const last = aggregate.attempts[aggregate.attempts.length - 1];
+                if (last !== undefined && last.trace === undefined) {
+                    return refused("missing-trace");
                 }
             }
             const bornInMerging = aggregate.state === "merging" || input.kind === "merging";
@@ -476,26 +461,17 @@ export function openWorkLedger(options) {
                 kind: input.kind,
                 born_in_merging: bornInMerging,
             };
-            if (input.subtaskId !== undefined) {
-                escalation.subtask_id = input.subtaskId;
-            }
             if (input.report !== undefined && input.report.trim().length > 0) {
                 escalation.report = input.report;
             }
             aggregate.escalation = escalation;
             // Freezing for a human consumes the in-flight update signal. Resume
-            // continues the stored intention; a newer FeatureStandard lands by admit.
+            // continues the stored intention; a newer TicketStandard lands by admit.
             delete aggregate.pending_fingerprint;
-            if (aggregate.plan !== undefined && input.subtaskId !== undefined) {
-                const subtask = aggregate.plan.subtasks.find((st) => st.id === input.subtaskId);
-                if (subtask !== undefined && subtask.state === "running") {
-                    subtask.state = "escalated";
-                }
-            }
             delete aggregate.bail;
             return await write(aggregate);
         },
-        async resumeReady(key) {
+        async resumeTicket(key) {
             const current = await loadOrRefuse(key);
             if (!current.ok) {
                 return current;
@@ -507,33 +483,19 @@ export function openWorkLedger(options) {
             if (aggregate.state !== "escalated" || aggregate.escalation === undefined) {
                 return refused("illegal-transition");
             }
-            const { kind, subtask_id } = aggregate.escalation;
-            aggregate.resumes = (aggregate.resumes ?? 0) + 1;
-            if (kind === "plan") {
-                delete aggregate.plan;
-                aggregate.state = "planning";
-                delete aggregate.invalid;
-                delete aggregate.escalation;
-                aggregate.bail = { expires_at: now() + bailDurationMs };
-                return await write(aggregate);
-            }
-            if (kind === "merging" || kind === "submitted" || kind === "assembly") {
-                aggregate.state = "integrating";
-                delete aggregate.escalation;
+            const { kind } = aggregate.escalation;
+            aggregate.resumes += 1;
+            delete aggregate.escalation;
+            aggregate.state = kind === "unit" ? "running" : "integrating";
+            if (aggregate.state === "integrating") {
                 aggregate.bail = { expires_at: now() + bailDurationMs };
-                return await write(aggregate);
             }
-            if (kind === "subtask" && subtask_id !== undefined && aggregate.plan !== undefined) {
-                const subtask = aggregate.plan.subtasks.find((st) => st.id === subtask_id);
-                if (subtask !== undefined) {
-                    subtask.state = "runnable";
-                }
-                aggregate.state = "running";
-                delete aggregate.escalation;
-                aggregate.bail = { expires_at: now() + bailDurationMs };
-                return await write(aggregate);
+            else {
+                // A human's resume of a unit starts it from zero: what it left is not picked up.
+                delete aggregate.workspace;
+                delete aggregate.first_stage_done;
             }
-            return refused("illegal-transition");
+            return await write(aggregate);
         },
         async cancel(key) {
             const current = await loadOrRefuse(key);
@@ -551,9 +513,6 @@ export function openWorkLedger(options) {
                 return { ok: true };
             }
             aggregate.state = "cancelled";
-            if (aggregate.plan !== undefined) {
-                aggregate.plan.subtasks = aggregate.plan.subtasks.map((st) => st.state === "integrated" ? st : { ...st, state: "cancelled" });
-            }
             delete aggregate.bail;
             return await write(aggregate);
         },
@@ -566,35 +525,34 @@ export function openWorkLedger(options) {
             if (aggregate.state === "done" || aggregate.state === "cancelled") {
                 return refused("illegal-transition");
             }
-            const workspaces = { ...aggregate.workspaces };
-            if (input.feature !== undefined) {
-                workspaces.feature = input.feature;
-            }
-            if (input.subtask !== undefined) {
-                workspaces.subtask = input.subtask;
-            }
-            aggregate.workspaces = workspaces;
+            aggregate.workspace = input.path;
+            // Declared anew: nothing is done in it yet.
+            delete aggregate.first_stage_done;
             return await write(aggregate);
         },
-        async clearWorkspace(input) {
-            const current = await loadOrRefuse(input.key);
+        async clearWorkspace(key) {
+            const current = await loadOrRefuse(key);
             if (!current.ok) {
                 return current;
             }
             const { aggregate } = current;
-            if (aggregate.workspaces === undefined) {
+            if (aggregate.workspace === undefined) {
                 return { ok: true };
             }
-            if (input.feature === true) {
-                delete aggregate.workspaces.feature;
-            }
-            if (input.subtask === true) {
-                delete aggregate.workspaces.subtask;
+            delete aggregate.workspace;
+            delete aggregate.first_stage_done;
+            return await write(aggregate);
+        },
+        async markFirstStageDone(key) {
+            const current = await loadOrRefuse(key);
+            if (!current.ok) {
+                return current;
             }
-            if (aggregate.workspaces.feature === undefined &&
-                aggregate.workspaces.subtask === undefined) {
-                delete aggregate.workspaces;
+            const { aggregate } = current;
+            if (aggregate.state !== "running" || aggregate.workspace === undefined) {
+                return refused("illegal-transition");
             }
+            aggregate.first_stage_done = true;
             return await write(aggregate);
         },
         async expireBail(key) {
@@ -606,19 +564,9 @@ export function openWorkLedger(options) {
             if (aggregate.bail === undefined || now() < aggregate.bail.expires_at) {
                 return refused("illegal-transition");
             }
-            if (aggregate.state === "planning") {
-                aggregate.state = "received";
+            if (!releaseRunningUnit(aggregate, true)) {
                 delete aggregate.bail;
-                return await write(aggregate);
             }
-            if (aggregate.state === "running" && aggregate.plan !== undefined) {
-                if (!releaseRunningSubtask(aggregate)) {
-                    clearSubtaskWorkspace(aggregate);
-                    delete aggregate.bail;
-                }
-                return await write(aggregate);
-            }
-            delete aggregate.bail;
             return await write(aggregate);
         },
         async releaseBail(key) {
@@ -627,19 +575,14 @@ export function openWorkLedger(options) {
                 return current;
             }
             const { aggregate } = current;
-            if (aggregate.state === "planning") {
-                aggregate.state = "received";
-                delete aggregate.bail;
-                return await write(aggregate);
+            if (aggregate.state !== "running") {
+                return refused("illegal-transition");
             }
-            if (aggregate.state === "running" && aggregate.plan !== undefined) {
-                if (!releaseRunningSubtask(aggregate)) {
-                    // Already free: no Subtask held, nothing to write.
-                    return { ok: true };
-                }
-                return await write(aggregate);
+            if (!releaseRunningUnit(aggregate, false)) {
+                // Already free: no unit held, nothing to write.
+                return { ok: true };
             }
-            return refused("illegal-transition");
+            return await write(aggregate);
         },
         async renewBail(key) {
             const current = await loadOrRefuse(key);
@@ -654,64 +597,49 @@ export function openWorkLedger(options) {
             return await write(aggregate);
         },
         async get(key) {
-            const found = await persist.load(key);
+            const found = await loadTicket(key);
             if (found === undefined) {
                 return { ok: false, code: "not-found" };
             }
             return { ok: true, aggregate: found };
         },
         async list() {
-            return await persist.listSummaries();
+            return ticketsOf(await persist.listSummaries());
         },
         async listInFlight() {
-            const summaries = await persist.listSummaries();
+            const summaries = ticketsOf(await persist.listSummaries());
             return summaries.filter((summary) => IN_FLIGHT.has(summary.state));
         },
+        async activeTickets(project) {
+            const summaries = ticketsOf(await persist.listSummaries());
+            return summaries.filter((s) => s.project === project && ACTIVE_STATES.has(s.state));
+        },
         async activeOn(project) {
-            const summaries = await persist.listSummaries();
+            const summaries = ticketsOf(await persist.listSummaries());
             return summaries.find((s) => s.project === project && ACTIVE_STATES.has(s.state));
         },
         async nextReceived(project) {
-            const summaries = await persist.listSummaries();
+            const summaries = ticketsOf(await persist.listSummaries());
             if (projectIsBusy(summaries, project)) {
                 return undefined;
             }
-            return pickReceived(summaries, project);
-        },
-        async nextRunnable(key) {
-            const found = await persist.load(key);
-            if (found?.plan === undefined) {
-                return undefined;
-            }
-            const runnable = found.plan.subtasks.filter((st) => st.state === "runnable");
-            if (runnable.length === 0) {
-                return undefined;
-            }
-            runnable.sort((a, b) => unblocksCount(b.id, found.plan?.subtasks ?? []) -
-                unblocksCount(a.id, found.plan?.subtasks ?? []));
-            return runnable[0]?.id;
+            const picked = await pickReceived(summaries, project);
+            return picked === undefined
+                ? undefined
+                : summaries.find((summary) => summary.key === picked.intention.key);
         },
         async listDeclaredWorkspaces() {
-            const summaries = await persist.listSummaries();
+            const summaries = ticketsOf(await persist.listSummaries());
             const listed = [];
             for (const summary of summaries) {
-                const aggregate = await persist.load(summary.key);
-                if (aggregate?.workspaces === undefined) {
-                    continue;
-                }
-                const row = { key: summary.key };
-                if (aggregate.workspaces.feature !== undefined) {
-                    row.feature = aggregate.workspaces.feature;
-                }
-                if (aggregate.workspaces.subtask !== undefined) {
-                    row.subtask = aggregate.workspaces.subtask;
-                }
-                if (row.feature !== undefined || row.subtask !== undefined) {
-                    listed.push(row);
+                const aggregate = await loadTicket(summary.key);
+                if (aggregate?.workspace !== undefined) {
+                    listed.push({ key: summary.key, path: aggregate.workspace });
                 }
             }
             return listed;
         },
+        ...openFeatureCommands({ persist, now }),
     };
 }
 //# sourceMappingURL=open-work-ledger.js.map