@bluewombat/runtime 0.9.0 → 0.11.0

package/dist/loop/features.js

@@ -1,4 +1,9 @@
-import { refreshWorkLine } from "./authority.js";
+import { existsSync } from "node:fs";
+import { rm } from "node:fs/promises";
+import { join } from "node:path";
+import { pathSegment } from "@bluewombat/conductor";
+import { CLI_NAME, } from "@bluewombat/manager-kit";
+import { publish, refreshWorkLine } from "./authority.js";
 import { cancelTicket, handleCancel as cancelTicketByKey, handleResume as resumeTicketByKey, } from "./deliveries.js";
 import { driveUntilBlocked } from "./drive.js";
 import { pushReport } from "./report.js";
@@ -69,6 +74,23 @@ async function admitFeature(input, feature) {
     // about work already made: nothing here restarts it.
     const before = await input.ledger.getFeature(feature.key);
     if (before.ok && before.aggregate.state !== "waiting") {
+        // The label that leaves the feature-test check out is the one thing a human can still change: it is
+        // honoured until the Feature is submitted, and read again by the check each time it runs.
+        if (before.aggregate.intention.skip_feature_test !== feature.skip_feature_test) {
+            const moved = await input.ledger.setFeatureSkipFeatureTest({
+                key: feature.key,
+                skip: feature.skip_feature_test,
+            });
+            if (moved.ok) {
+                input.journal.append({
+                    event: "skip-feature-test",
+                    key: feature.key,
+                    skip: feature.skip_feature_test,
+                });
+                input.trace(`feature    ${feature.key} ${feature.skip_feature_test ? "now" : "no longer"} skips the feature-test check`);
+                return;
+            }
+        }
         input.journal.append({ event: "skipped", key: feature.key, state: before.aggregate.state });
         return;
     }
@@ -82,6 +104,7 @@ async function admitFeature(input, feature) {
         external_id: feature.external_id,
         blocked_by: feature.blocked_by,
         merge_when_ready: feature.merge_when_ready,
+        ...(feature.skip_feature_test ? { skip_feature_test: true } : {}),
         ...(feature.title === undefined ? {} : { title: feature.title }),
         ...(feature.source === undefined ? {} : { source: feature.source }),
     };
@@ -131,6 +154,9 @@ export async function cancelFeatureFlow(input, key) {
     if (feature.line !== undefined) {
         await input.tickets.dropLine?.(feature.line);
     }
+    if (input.featureDelivery !== undefined) {
+        await rm(featureWorkspace(input.featureDelivery, key), { recursive: true, force: true });
+    }
     const cancelled = await input.ledger.cancelFeature(key);
     if (!cancelled.ok) {
         return;
@@ -174,6 +200,10 @@ export async function advanceProject(input, project) {
             return undefined;
     }
 }
+/** What the tracker says of a Ticket beside its words. */
+function marksOf(entry) {
+    return { featureTest: entry.featureTest === true };
+}
 function refOf(feature) {
     const { intention } = feature;
     return {
@@ -188,7 +218,7 @@ function lineOf(feature) {
     const id = feature.intention.external_id ?? feature.intention.key;
     return `feature/${id.replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^-+|-+$/g, "")}`;
 }
-function admissionOf(ticket, feature, among) {
+function admissionOf(ticket, feature, among, marks) {
     return {
         key: ticket.key,
         project: ticket.project,
@@ -202,8 +232,47 @@ function admissionOf(ticket, feature, among) {
         ...(feature.line === undefined ? {} : { line: feature.line }),
         ...(ticket.title === undefined ? {} : { title: ticket.title }),
         ...(ticket.source === undefined ? {} : { source: ticket.source }),
+        ...(marks.featureTest ? { featureTest: true } : {}),
     };
 }
+/**
+ * What is wrong with a Feature of a Project that proves its Features by a feature-test suite: it holds
+ * no feature-test Ticket and is not marked to skip the check, holds several, or its feature-test Ticket may start
+ * before the others have landed. Nothing: a Project without the check, or a Feature that skips it.
+ */
+function featureTestRefusal(input, feature, live) {
+    if (input.options.builder.featureTest === undefined ||
+        feature.intention.skip_feature_test === true) {
+        return undefined;
+    }
+    const holding = live.filter((entry) => entry.featureTest);
+    const head = "This Project proves each Feature by a feature tests, run once on the whole Feature.";
+    if (holding.length === 0) {
+        return `${head} The Feature has no feature-test Ticket and is not marked skip-feature-test: add the feature-test Ticket (the scenarios agreed with the operator, blocked by every other Ticket), or mark the Feature to skip the check.`;
+    }
+    if (holding.length > 1) {
+        return `${head} The Feature holds ${holding.length} feature-test Tickets: it holds one, with all its scenarios.`;
+    }
+    const only = holding[0];
+    const others = live.filter((entry) => !entry.featureTest).map((entry) => entry.ticket.key);
+    const missing = others.filter((key) => !only?.ticket.blocked_by.includes(key));
+    if (only !== undefined && missing.length > 0) {
+        return `${head} The feature-test Ticket ${only.ticket.key} must be blocked by every other Ticket of the Feature, so that it lands last. It is not blocked by: ${missing.join(", ")}.`;
+    }
+    return undefined;
+}
+/** Whether a Feature still holds a feature-test Ticket that was not cancelled. */
+async function holdsLiveFeatureTestTicket(input, feature) {
+    for (const key of feature.tickets) {
+        const got = await input.ledger.get(key);
+        if (got.ok &&
+            got.aggregate.intention.featureTest === true &&
+            got.aggregate.state !== "cancelled") {
+            return true;
+        }
+    }
+    return false;
+}
 /**
  * Open the next Feature that may: waiting, nothing blocking it, and every one
  * of its Tickets written. Until then it waits and nothing is made.
@@ -232,6 +301,18 @@ async function openNextFeature(input, project) {
         });
         return;
     }
+    const refusal = featureTestRefusal(input, feature, live);
+    if (refusal !== undefined) {
+        input.journal.append({ event: "invalid", key: feature.intention.key, reason: refusal });
+        await pushReport(input, {
+            event: "invalid",
+            key: feature.intention.key,
+            project,
+            eventId: `${feature.intention.key}:invalid:feature-test:${refusal}`,
+            fields: { reason: refusal },
+        }, TO);
+        return;
+    }
     const target = input.workLine.target;
     let line;
     if (input.authority !== undefined &&
@@ -269,7 +350,7 @@ async function openNextFeature(input, project) {
     }
     const withLine = { ...feature, ...(line === undefined ? {} : { line }) };
     for (const entry of live) {
-        await input.ledger.admit(admissionOf(entry.ticket, withLine, among));
+        await input.ledger.admit(admissionOf(entry.ticket, withLine, among, marksOf(entry)));
     }
     input.journal.append({
         event: "feature-opened",
@@ -306,6 +387,9 @@ async function refreshOnto(input, branch) {
     const refreshed = await refreshWorkLine({
         workLineStable: input.workLine.stable,
         workLineTarget: branch,
+        // A Feature's line that has not moved is brought up to the final branch
+        // first, so its Tickets read the code as it now is.
+        workLineBase: branch === input.workLine.target ? undefined : input.workLine.target,
         refreshArgv: input.options.authority?.refreshArgv ?? [],
         timeoutMs: input.options.timeoutMs,
         env: input.workLine.env,
@@ -356,8 +440,25 @@ async function syncTicket(input, feature, entry, known) {
     }
     // Only a Ticket that has not started takes the new words: the tracker's
     // fingerprint moves with every comment, and a unit in flight is not rewritten.
-    if (state === "received" && current.aggregate.intention.fingerprint !== ticket.fingerprint) {
-        await input.ledger.admit(admissionOf(ticket, feature, known));
+    // The label that marks the feature-test Ticket is not in the words, so it moves no
+    // fingerprint: it is compared on its own.
+    const marks = marksOf(entry);
+    const holdsFeatureTest = current.aggregate.intention.featureTest === true;
+    if (state === "received" &&
+        (current.aggregate.intention.fingerprint !== ticket.fingerprint ||
+            holdsFeatureTest !== marks.featureTest)) {
+        await input.ledger.admit(admissionOf(ticket, feature, known, marks));
+    }
+    // A Feature that is not put through the feature-test check has no use of the Ticket that holds it.
+    if (feature.intention.skip_feature_test === true && marks.featureTest && LIVE.has(state)) {
+        input.journal.append({
+            event: "feature-test-ticket-cancelled",
+            key: ticket.key,
+            feature: feature.intention.key,
+        });
+        input.trace(`feature    ${feature.intention.key} skips the feature-test check: ticket ${ticket.key} is cancelled`);
+        await cancelTicketByKey({ key: ticket.key, project: ticket.project }, input);
+        return;
     }
     if (entry.resume && state === "escalated") {
         await resumeTicketByKey({ key: ticket.key, project: ticket.project }, input);
@@ -366,31 +467,21 @@ async function syncTicket(input, feature, entry, known) {
 async function advanceOpenFeature(input, feature) {
     const project = feature.intention.project;
     await syncTickets(input, feature);
-    const held = await input.ledger.activeOn(project);
-    if (held?.state === "escalated") {
+    const limit = input.options.ticket.maxParallel ?? 1;
+    // A Ticket waiting for a person holds its place. When every place is held
+    // that way, nothing can move until someone answers.
+    const holding = await input.ledger.activeTickets(project);
+    if (holding.length >= limit && holding.every((summary) => summary.state === "escalated")) {
         return undefined;
     }
-    const refreshed = await refreshOnto(input, feature.line ?? input.workLine.target);
-    if (!refreshed) {
+    // Nothing is taken if the line cannot be reached. Conductor refreshes it again
+    // for each Ticket it cuts and aligns, which is what keeps a Ticket current
+    // while others land; this is the check that starts nothing at all.
+    if (!(await refreshOnto(input, feature.line ?? input.workLine.target))) {
         return undefined;
     }
-    let tickets = await ticketsOf(input, feature);
-    let run;
-    let pending = tickets.find((summary) => LIVE.has(summary.state));
-    // A Ticket that landed moved the line: the next one is cut from where it is
-    // now, in this same pass, not a poll later.
-    while (pending !== undefined) {
-        run = await driveUntilBlocked(input, project, pending.key);
-        tickets = await ticketsOf(input, feature);
-        pending = tickets.find((summary) => LIVE.has(summary.state));
-        const interrupted = input.options.interruptFlag?.interrupted === true;
-        if (run.outcome !== "done" ||
-            interrupted ||
-            pending === undefined ||
-            !(await refreshOnto(input, feature.line ?? input.workLine.target))) {
-            break;
-        }
-    }
+    const run = await driveTickets(input, feature, project, limit);
+    const tickets = await ticketsOf(input, feature);
     await reportLanded(input, feature, tickets);
     const settled = tickets.every((summary) => summary.state === "done" || summary.state === "cancelled");
     if (settled && tickets.length > 0) {
@@ -402,6 +493,53 @@ async function advanceOpenFeature(input, feature) {
     }
     return run;
 }
+/** Where a Ticket is while Host has something to drive it through. */
+const DRIVEN = new Set([
+    "running",
+    "integrating",
+    "submitted",
+    "merging",
+]);
+/**
+ * Work the Tickets of an open Feature, up to `limit` at a time.
+ *
+ * Each place is a worker: it drives a Ticket the Project already holds, else
+ * takes the next one that may start, and goes on to another when its own is
+ * done or is only waiting for the outside. A Ticket waiting on a check holds a
+ * place but not a worker, so the others do not wait with it. With a limit of 1
+ * this is one Ticket after the other.
+ */
+async function driveTickets(input, feature, project, limit) {
+    // Once, before anything runs at the same time: it clears what a dead process
+    // left, which must not be done under a Ticket that is being driven.
+    await input.conductor.reconcile(project);
+    const interrupted = () => input.options.interruptFlag?.interrupted === true;
+    const queue = (await ticketsOf(input, feature))
+        .filter((summary) => DRIVEN.has(summary.state))
+        .map((summary) => summary.key);
+    let last;
+    const worker = async () => {
+        while (!interrupted()) {
+            const key = queue.shift() ?? (await input.conductor.claimNext(project))?.key;
+            if (key === undefined) {
+                return;
+            }
+            const run = await driveUntilBlocked(input, project, key, true);
+            last = run;
+            // A refusal is about the run, not the Ticket: the next one would meet it too.
+            if (run.outcome === "refused") {
+                return;
+            }
+        }
+    };
+    await Promise.all(Array.from({ length: Math.max(1, limit) }, worker));
+    if (last === undefined && (await input.ledger.activeTickets(project)).length === 0) {
+        const waiting = (await ticketsOf(input, feature)).some((s) => s.state === "received");
+        // Nothing held and nothing could start: what remains waits on what cannot finish.
+        return waiting ? { outcome: "idle" } : undefined;
+    }
+    return last;
+}
 /** One `progress` per Ticket that landed, in the words the tracker already has. */
 async function reportLanded(input, feature, tickets) {
     const total = feature.tickets.length;
@@ -418,8 +556,15 @@ async function reportLanded(input, feature, tickets) {
         }, TO);
     }
 }
-async function escalateFeature(input, feature, report) {
-    const escalated = await input.ledger.escalateFeature({ key: feature.intention.key, report });
+async function escalateFeature(input, feature, report, 
+/** Where the line stopped and who refused it, when the caller knows. */
+origin = undefined) {
+    const escalated = await input.ledger.escalateFeature({
+        key: feature.intention.key,
+        report,
+        ...(origin === undefined ? {} : { kind: origin.kind }),
+        ...(origin?.refusedBy === undefined ? {} : { refusedBy: origin.refusedBy }),
+    });
     if (!escalated.ok) {
         return;
     }
@@ -431,12 +576,87 @@ async function escalateFeature(input, feature, report) {
         key: feature.intention.key,
         project: feature.intention.project,
         eventId: `${feature.intention.key}:escalated:${round}`,
-        fields: { reason: report, stage: "submitting" },
+        // The assembled line refused by a check is not a Submission refused: say which it was.
+        fields: { reason: report, stage: origin?.kind === "assembly" ? "integrating" : "submitting" },
     }, TO);
 }
+/** Where a Feature's own work is done: apart from every Ticket's workspace, which Host clears of strays. */
+function featureWorkspace(delivery, key) {
+    return join(delivery.workspaces, pathSegment(key));
+}
+/** Where the Feature's work is, and where it goes: the Feature stands where a Ticket stood, the final line where the Feature's was. */
+function featureUnit(input, delivery, feature) {
+    return {
+        key: feature.intention.key,
+        intention: feature.intention.intention,
+        title: feature.intention.title,
+        noun: "feature",
+        workspace: featureWorkspace(delivery, feature.intention.key),
+        // The Gates read the published branch, and the copy of the Feature's line is on it.
+        judgeWorkspace: input.workLine.stable,
+        target: input.workLine.target ?? "",
+        line: delivery.targetStable,
+    };
+}
+/** What a Feature's delivery reads of it, and how the Feature keeps what the delivery decides. */
+function featureStore(input, feature) {
+    const key = feature.intention.key;
+    const failed = (result) => result.ok ? undefined : { outcome: "refused", code: "illegal-transition" };
+    return {
+        async read() {
+            const got = await input.ledger.getFeature(key);
+            if (!got.ok) {
+                return undefined;
+            }
+            const aggregate = got.aggregate;
+            const parked = aggregate.parked_refusal;
+            const report = parked?.report ?? aggregate.submission?.last_report;
+            const refusedBy = parked?.refused_by ?? aggregate.submission?.last_refused_by;
+            return {
+                sentBack: report === undefined ? undefined : { report, refusedBy },
+                spent: (aggregate.submission?.refusals ?? 0) +
+                    (aggregate.parked_refusals ?? 0) +
+                    (aggregate.submission?.realigns ?? 0),
+                submission: aggregate.submission === undefined
+                    ? undefined
+                    : { reference: aggregate.submission.reference },
+            };
+        },
+        async freeze(frozen) {
+            await escalateFeature(input, feature, frozen.report ?? "The line was stopped, with no reason given.", { kind: frozen.kind, refusedBy: frozen.refusedBy });
+            return { outcome: "escalated", key };
+        },
+        async park(why) {
+            return failed(await input.ledger.recordFeatureParkedRefusal({
+                key,
+                report: why.report,
+                ...(why.refusedBy === undefined ? {} : { refusedBy: why.refusedBy }),
+            }));
+        },
+        async unpark() {
+            return failed(await input.ledger.clearFeatureParkedRefusal(key));
+        },
+        async refuse(why) {
+            return failed(await input.ledger.recordFeatureRefusal({
+                key,
+                report: why.report,
+                ...(why.refusedBy === undefined ? {} : { refusedBy: why.refusedBy }),
+            }));
+        },
+        async realign() {
+            return failed(await input.ledger.recordFeatureRealign(key));
+        },
+    };
+}
 /**
- * Every Ticket has landed: the line goes to the Authority. With none, the work
+ * Every Ticket has landed: the line is brought up to date with the one it is
+ * folded into, checked, and put in front of the Authority. With none, the work
  * is already in the work line and the Feature is done.
+ *
+ * It is delivered the way a Ticket is — see `openDelivery` — with the final line
+ * merged into the Feature's work, its own checks run on the result, and a fix
+ * when something refuses it. Only where the work is offered differs: the line
+ * is pushed under its own name rather than a name made for it.
  */
 async function closeFeature(input, feature, tickets) {
     const key = feature.intention.key;
@@ -445,18 +665,100 @@ async function closeFeature(input, feature, tickets) {
         await escalateFeature(input, feature, "Every Ticket was abandoned, so nothing was made.");
         return;
     }
+    if (input.options.builder.featureTest !== undefined &&
+        feature.intention.skip_feature_test !== true &&
+        !(await holdsLiveFeatureTestTicket(input, feature))) {
+        await escalateFeature(input, feature, "This Feature is not marked skip-feature-test and holds no feature-test Ticket: it was cancelled while the Feature skipped the check, and the mark was taken off since. Mark the Feature skip-feature-test again to leave the check out.");
+        return;
+    }
     if (input.authority === undefined || feature.line === undefined) {
         await input.ledger.markFeatureSubmitted({ key, reference: "local" });
         await input.ledger.markFeatureDone(key);
         await reportDone(input, feature, undefined, undefined);
         return;
     }
-    if (feature.submission !== undefined) {
-        await input.ledger.markFeatureSubmitted({ key, reference: feature.submission.reference });
+    const delivery = input.featureDelivery;
+    const target = input.workLine.target;
+    const publishArgv = input.options.authority?.publishArgv;
+    if (delivery === undefined || target === undefined || publishArgv === undefined) {
         return;
     }
-    const target = input.workLine.target;
-    if (target === undefined) {
+    const unit = featureUnit(input, delivery, feature);
+    const clean = async () => {
+        await rm(unit.workspace, { recursive: true, force: true });
+    };
+    // The Feature's work is cut from its line the way a Ticket's is, once; a
+    // pass that sent it to the fix finds it where it was left. A resume is the
+    // one time the line may have moved under it, by a person: what it gained is
+    // then merged into the work, which keeps what it holds.
+    if (existsSync(unit.workspace)) {
+        if (feature.workspace_stale === true && !(await takeInLine(input, feature, unit))) {
+            return;
+        }
+    }
+    else {
+        if (!(await refreshOnto(input, feature.line))) {
+            return;
+        }
+        const isolated = await input.transformers.isolate({
+            id: `${key}:close`,
+            context: key,
+            parent: input.workLine.stable,
+            child: unit.workspace,
+            durationMs: input.options.timeoutMs,
+        });
+        if (isolated.outcome !== "isolated") {
+            // Nothing was spent: the next pass tries again.
+            await clean();
+            return;
+        }
+        // The checks run here, so it is prepared the way a Ticket's workspace is.
+        const warmed = await delivery.warm?.prepare({
+            workspace: unit.workspace,
+            durationMs: delivery.warm.durationMs,
+        });
+        if (warmed !== undefined && warmed.outcome !== "warmed") {
+            await clean();
+            return;
+        }
+    }
+    if (feature.workspace_stale === true) {
+        await input.ledger.markFeatureWorkspaceCurrent(key);
+    }
+    const prepared = await delivery.delivery.prepare(unit, featureStore(input, feature));
+    if (prepared !== "ready") {
+        return;
+    }
+    // Offer it. What was made in the workspace goes back into the Feature's line
+    // and the line is pushed under its own name, which is where the Authority
+    // reads it and where its Submission is.
+    const folded = await input.transformers.integrate({
+        id: `${key}:close`,
+        context: key,
+        parent: input.workLine.stable,
+        child: unit.workspace,
+        durationMs: input.options.timeoutMs,
+        subject: `Merge ${target} into ${feature.line}`,
+        mergeSubject: `Merge ${target} into ${feature.line}`,
+    });
+    if (folded.outcome === "interrupted") {
+        return;
+    }
+    if (folded.outcome !== "integrated") {
+        await escalateFeature(input, feature, "The Feature's work could not be folded into its line.");
+        return;
+    }
+    const published = await publish({
+        argv: publishArgv,
+        cwd: input.workLine.stable,
+        id: key,
+        ref: feature.line,
+        target,
+        timeoutMs: input.options.timeoutMs,
+        env: input.workLine.env,
+    });
+    if (!published.ok) {
+        await escalateFeature(input, feature, published.reason);
         return;
     }
     const submitted = await input.authority.submit({
@@ -477,6 +779,7 @@ async function closeFeature(input, feature, tickets) {
         return;
     }
     await input.ledger.markFeatureSubmitted({ key, reference: submitted.reference });
+    await clean();
     await pushReport(input, {
         event: "submitted",
         key,
@@ -486,8 +789,44 @@ async function closeFeature(input, feature, tickets) {
     }, TO);
 }
 /**
- * The line is with the Authority. If the Feature merges by itself, the checks
- * decide; otherwise a human folds it and the system waits, starting nothing.
+ * Bring what a resumed Feature's line gained since its work was cut into that
+ * work, without discarding what the work holds (the fix's own commits, even
+ * refused ones: a person may want them). Answers whether the pass goes on:
+ * not when the line could not be reached or the merge was interrupted (the next
+ * pass tries again), nor when it conflicts — that is for a person, and the
+ * work is left as it was.
+ */
+async function takeInLine(input, feature, unit) {
+    if (!(await refreshOnto(input, feature.line))) {
+        return false;
+    }
+    const taken = await input.transformers.integrate({
+        id: `${unit.key}:resume`,
+        context: unit.key,
+        parent: unit.workspace,
+        child: input.workLine.stable,
+        durationMs: input.options.timeoutMs,
+        subject: "Work left when the Feature stopped",
+        mergeSubject: `Merge ${feature.line} into the feature`,
+    });
+    switch (taken.outcome) {
+        case "integrated":
+            return true;
+        case "interrupted":
+            return false;
+        case "conflict":
+            await escalateFeature(input, feature, `The line ${feature.line} gained commits since the Feature's work was made, and they conflict with it: both changed the same places. The work was left as it was. Settle it on the line, or run \`${CLI_NAME} restart ${unit.key}\` to make the work again from the line, then resume.`, { kind: "assembly" });
+            return false;
+        default:
+            await escalateFeature(input, feature, `What the line ${feature.line} gained could not be merged into the Feature's work. The work was left as it was.`, { kind: "assembly" });
+            return false;
+    }
+}
+/**
+ * The line is with the Authority. If the Feature merges by itself, its gates
+ * decide, and a line the target moved on from goes back to be brought up to
+ * date, exactly as a Ticket does; otherwise a human folds it and the system
+ * waits, starting nothing.
  */
 async function settleFeature(input, feature) {
     const submission = feature.submission;
@@ -506,36 +845,16 @@ async function settleFeature(input, feature) {
         }
         return;
     }
-    if (!(await refreshOnto(input, feature.line))) {
-        return;
-    }
-    const judged = await input.transformers.implement({
-        id: `${key}:judgement`,
-        context: key,
-        stage: "assembly",
-        produce: false,
-        intention: feature.intention.intention,
-        workspace: input.workLine.stable,
-    });
-    if (judged.outcome === "interrupted" || judged.outcome === "invalid-invocation") {
-        return;
-    }
-    if (judged.outcome === "escalated") {
-        const last = judged.traces.at(-1);
-        const why = last?.report ?? "The line was refused, with no reason given.";
-        await escalateFeature(input, feature, last?.refusedBy === undefined ? why : `${last.refusedBy}: ${why}`);
+    const delivery = input.featureDelivery;
+    if (delivery === undefined || !(await refreshOnto(input, feature.line))) {
         return;
     }
-    const folded = await input.authority.fold({ reference: submission.reference });
-    if (folded.outcome === "unavailable") {
+    const settled = await delivery.delivery.settle(featureUnit(input, delivery, feature), featureStore(input, feature));
+    if (!("folded" in settled)) {
         return;
     }
-    if (folded.outcome === "conflict") {
-        await escalateFeature(input, feature, folded.reason);
-        return;
-    }
-    await input.ledger.markFeatureDone(key, { reference: folded.reference });
-    await reportDone(input, feature, submission.reference, folded.reference);
+    await input.ledger.markFeatureDone(key, { reference: settled.reference });
+    await reportDone(input, feature, submission.reference, settled.reference);
 }
 async function reportDone(input, feature, reference, integrationReference) {
     const key = feature.intention.key;
@@ -553,6 +872,29 @@ async function reportDone(input, feature, reference, integrationReference) {
         },
     }, TO);
 }
+/**
+ * Restart an escalated Feature with a fresh workspace: what it holds is removed
+ * and the Feature is resumed, so the next pass cuts its work again from the
+ * line and judges that. Nothing is said to the tracker and nothing is fetched.
+ */
+export async function restartFeature(input, key) {
+    const got = await input.ledger.getFeature(key);
+    if (!got.ok) {
+        return { ok: false, code: "not-found" };
+    }
+    if (got.aggregate.state !== "escalated") {
+        return { ok: false, code: "not-escalated", state: got.aggregate.state };
+    }
+    if (input.featureDelivery !== undefined) {
+        await rm(featureWorkspace(input.featureDelivery, key), { recursive: true, force: true });
+    }
+    const resumed = await input.ledger.resumeFeature(key);
+    if (!resumed.ok) {
+        return { ok: false, code: "not-escalated", state: got.aggregate.state };
+    }
+    input.journal.append({ event: "restarted", key });
+    return { ok: true };
+}
 /** Abandon a Feature or a Ticket by key: whichever the ledger knows. */
 export async function cancelKey(input, key) {
     const feature = await input.ledger.getFeature(key);