@jitsusama/agentic-harness.core 0.1.0

package/dist/review/ask/audit.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Weighing what other people asked for against what the change does.
+ *
+ * A change under review usually arrives with threads already on it,
+ * some of them answered by later commits and never marked resolved.
+ * Working out which is slow, and getting it wrong is worse than slow:
+ * replying "fixed" to a thread nothing addressed reads as a brush-off,
+ * and re-fixing something already fixed wastes a round trip.
+ *
+ * So an audit judges each thread and says why, and that is all it
+ * does. It never posts, and it raises no findings: these are other
+ * people's words, and turning them into findings would put them into
+ * the review as ours. The reply stays a human decision, better
+ * informed.
+ */
+import type { CritiqueDeps } from "./critique.js";
+import { type Participant } from "./identity.js";
+import { type AskRun, type RoundGiven } from "./run.js";
+/**
+ * Where an inbound thread stands against the change.
+ *
+ * `elsewhere` is the one worth naming separately: in a stack, a thread
+ * on one change is often answered by a sibling, and reporting that as
+ * addressed would send somebody looking in the wrong diff.
+ */
+export type Standing = "addressed" | "outstanding" | "elsewhere" | "unclear";
+/** One judgement about one inbound thread. */
+export interface ThreadAudit {
+    threadIndex: number;
+    participantId: string;
+    standing: Standing;
+    rationale: string;
+    /** Where in the change the auditor saw it, when it says. */
+    evidence?: string;
+}
+/** What came out of one auditor's answer. */
+export interface AuditHarvest {
+    audits: ThreadAudit[];
+    warnings: string[];
+}
+/** What to audit, and who weighs it. */
+export interface AuditRequest {
+    auditor: Participant;
+    prompt: string;
+    seq: number;
+    /** The threads put up, by the index a reader cites them as. */
+    threadIndices: number[];
+    /**
+     * The commit this round was formed against.
+     *
+     * Recorded for the same reason a council records one: a round that
+     * cannot say what it read cannot be judged against the change
+     * afterwards, and a standing on a thread is exactly the kind of
+     * answer that ages when the branch moves.
+     */
+    witness?: string;
+    /** Said when the tree the reviewers read was not that commit. */
+    unpinned?: string;
+    /** What the auditor was handed, besides the change. */
+    given?: RoundGiven;
+}
+/** The round, the judgements, and anything worth saying. */
+export interface AuditResult {
+    run: AskRun;
+    audits: ThreadAudit[];
+    warnings: string[];
+}
+/** Read one auditor's answer, warning about what it dropped. */
+export declare function harvestAudits(text: string, participantId: string, threadIndices: readonly number[]): AuditHarvest;
+/** Put the inbound threads to an auditor and gather its judgements. */
+export declare function runAudit(request: AuditRequest, deps: CritiqueDeps): Promise<AuditResult>;

package/dist/review/ask/audit.js

@@ -0,0 +1,158 @@
+/**
+ * Weighing what other people asked for against what the change does.
+ *
+ * A change under review usually arrives with threads already on it,
+ * some of them answered by later commits and never marked resolved.
+ * Working out which is slow, and getting it wrong is worse than slow:
+ * replying "fixed" to a thread nothing addressed reads as a brush-off,
+ * and re-fixing something already fixed wastes a round trip.
+ *
+ * So an audit judges each thread and says why, and that is all it
+ * does. It never posts, and it raises no findings: these are other
+ * people's words, and turning them into findings would put them into
+ * the review as ours. The reply stays a human decision, better
+ * informed.
+ */
+import { askOne } from "./council.js";
+import { participantIdentity } from "./identity.js";
+import { newRunId, whatItGave, whatItRead, } from "./run.js";
+import { ANSWER_WAS_CUT_OFF, isRecord, readAnswer, wireText, wireWhole, } from "./wire.js";
+/** The standings an auditor may report. */
+const STANDINGS = [
+    "addressed",
+    "outstanding",
+    "elsewhere",
+    "unclear",
+];
+/** Read one auditor's answer, warning about what it dropped. */
+export function harvestAudits(text, participantId, threadIndices) {
+    const { parsed, truncated } = readAnswer(text, "audits");
+    const held = parsed?.audits;
+    if (!Array.isArray(held)) {
+        return {
+            audits: [],
+            warnings: [
+                "Nothing in this answer parsed as an audits array, so no judgements could be read from it.",
+            ],
+        };
+    }
+    const put = new Set(threadIndices);
+    const audits = [];
+    const warnings = [];
+    if (truncated)
+        warnings.push(ANSWER_WAS_CUT_OFF);
+    for (const [index, entry] of held.entries()) {
+        const one = readAudit(entry, index, participantId, put, warnings);
+        if (one !== undefined)
+            audits.push(one);
+    }
+    return { audits, warnings };
+}
+/** Put the inbound threads to an auditor and gather its judgements. */
+export async function runAudit(request, deps) {
+    const startedAt = deps.now();
+    const id = newRunId("audit", startedAt, request.seq);
+    // Nothing to audit means nobody to ask, and holding no
+    // participants is how the run says it asked nobody rather than
+    // that somebody answered with nothing.
+    if (request.threadIndices.length === 0) {
+        return {
+            run: {
+                id,
+                round: "audit",
+                startedAt: startedAt.toISOString(),
+                participants: [],
+                outcomes: [],
+                ...whatItRead(request),
+                ...whatItGave(request),
+            },
+            audits: [],
+            warnings: [],
+        };
+    }
+    // One auditor rather than a roster, so askRoster would be a fan-out
+    // of one. It still reports: a lone audit reading a long thread looks
+    // just as hung as six reviewers do. That is `askOne`'s job now, said
+    // once for every round with a single participant rather than spelled
+    // out here in beats the judge then forgot to copy.
+    const answer = await askOne(request.auditor, request.prompt, id, deps);
+    deps.progress?.finish();
+    const warnings = [];
+    const audits = [];
+    const outcome = (() => {
+        if ("failure" in answer) {
+            return {
+                participantId: request.auditor.id,
+                findingIds: [],
+                failure: answer.failure,
+            };
+        }
+        const harvest = harvestAudits(answer.text, request.auditor.id, request.threadIndices);
+        audits.push(...harvest.audits);
+        for (const warning of harvest.warnings) {
+            warnings.push(`${request.auditor.id}: ${warning}`);
+        }
+        return {
+            participantId: request.auditor.id,
+            // An audit raises no findings, on purpose.
+            findingIds: [],
+            ...(answer.stopped === undefined ? {} : { stopped: answer.stopped }),
+            ...(answer.answerPath === undefined
+                ? {}
+                : { answerPath: answer.answerPath }),
+            ...(answer.usage === undefined ? {} : { usage: answer.usage }),
+        };
+    })();
+    return {
+        run: {
+            id,
+            round: "audit",
+            startedAt: startedAt.toISOString(),
+            // Held as a judge: an auditor weighs what exists rather than
+            // finding anything, which is the judging role.
+            participants: [participantIdentity("judge", request.auditor)],
+            outcomes: [outcome],
+            ...whatItRead(request),
+            ...whatItGave(request),
+        },
+        audits,
+        warnings,
+    };
+}
+/** One judgement, or nothing plus a warning saying why. */
+function readAudit(entry, index, participantId, put, warnings) {
+    const at = `audits[${index}]`;
+    if (!isRecord(entry)) {
+        warnings.push(`${at} is not an object, so it was dropped.`);
+        return undefined;
+    }
+    const threadIndex = wireWhole(entry.threadIndex);
+    if (threadIndex === undefined) {
+        warnings.push(`${at} names no thread, so it was dropped.`);
+        return undefined;
+    }
+    if (!put.has(threadIndex)) {
+        warnings.push(`${at} judges thread ${threadIndex}, which was not among the threads put up, so it was dropped.`);
+        return undefined;
+    }
+    const standing = wireText(entry.standing);
+    if (standing === undefined || !STANDINGS.includes(standing)) {
+        warnings.push(`${at} reports the standing "${standing ?? "nothing"}", which is not one of ${STANDINGS.join(", ")}, so it was dropped.`);
+        return undefined;
+    }
+    const rationale = wireText(entry.rationale);
+    if (rationale === undefined) {
+        // An audit exists to inform a reply, and a standing with no
+        // argument gives the person replying nothing to say.
+        warnings.push(`${at} gives no rationale, so it was dropped: a standing with no argument gives whoever replies nothing to say.`);
+        return undefined;
+    }
+    const evidence = wireText(entry.evidence);
+    return {
+        threadIndex,
+        participantId,
+        standing: standing,
+        rationale,
+        ...(evidence === undefined ? {} : { evidence }),
+    };
+}

package/dist/review/ask/collect.d.ts

@@ -0,0 +1,41 @@
+import type { AskAnswer, CouncilDeps, CouncilResult } from "./council.js";
+import type { AskRun } from "./run.js";
+/**
+ * What collecting a round needs, which is less than running one.
+ *
+ * No `ask`, because nobody is being asked: the answers already exist.
+ * No `opened`, because the round was written down when it opened and
+ * that is how it was found. No clock, because a collected round keeps
+ * the time it started rather than the time somebody noticed it.
+ */
+export type CollectDeps = Pick<CouncilDeps, "record"> & Partial<Pick<CouncilDeps, "progress">> & {
+    /**
+     * Persist the round as each participant is filed.
+     *
+     * Collecting writes findings against the change and nothing
+     * undoes that. Filing every one of them and recording the round
+     * once at the end leaves a window where the findings exist and
+     * the round still says nobody collected it, and the only thing
+     * anybody can do with such a round is collect it again, which
+     * files all of them a second time.
+     *
+     * Written after each participant instead, so an interrupted
+     * collect leaves durable progress and the next one skips what is
+     * already there. Optional, and a caller that omits it has the
+     * window back.
+     */
+    progressed?(run: AskRun): Promise<void>;
+};
+/**
+ * Finish a round from what its reviewers left behind.
+ *
+ * The round that opened is the round that settles: its id, its start
+ * time, its participants and their order all come off the record
+ * rather than being minted again, because a collected round is the
+ * same round arriving late and a new id would make it a second one.
+ *
+ * Every answer goes through the same recording path a live reply
+ * takes, so a finding collected an hour afterwards is numbered,
+ * anchored and warned about exactly as it would have been at the time.
+ */
+export declare function collectRound(run: AskRun, answers: ReadonlyMap<string, AskAnswer>, deps: CollectDeps): Promise<CouncilResult>;

package/dist/review/ask/collect.js

@@ -0,0 +1,82 @@
+import { recordReply } from "./council.js";
+import { settleReplies } from "./progress.js";
+import { whatItRead } from "./run.js";
+/** Said for a participant whose answer is not on disk. */
+const NOTHING_LEFT = "nothing was left on disk to collect, so whatever this reviewer found is gone";
+/**
+ * Finish a round from what its reviewers left behind.
+ *
+ * The round that opened is the round that settles: its id, its start
+ * time, its participants and their order all come off the record
+ * rather than being minted again, because a collected round is the
+ * same round arriving late and a new id would make it a second one.
+ *
+ * Every answer goes through the same recording path a live reply
+ * takes, so a finding collected an hour afterwards is numbered,
+ * anchored and warned about exactly as it would have been at the time.
+ */
+export async function collectRound(run, answers, deps) {
+    const warnings = [];
+    const held = new Map(run.outcomes.map((one) => [one.participantId, one]));
+    const outcomes = await settleReplies(run.participants, async (participant) => {
+        // An outcome the round already has is left alone. A retry
+        // can substitute one into an unsettled round before anybody
+        // collects it, and those findings are in the store already:
+        // recording them again would file one observation twice and
+        // number it twice.
+        const already = held.get(participant.id);
+        if (already !== undefined)
+            return already;
+        const answer = answers.get(participant.id);
+        if (answer === undefined) {
+            return {
+                participantId: participant.id,
+                findingIds: [],
+                failure: NOTHING_LEFT,
+            };
+        }
+        const outcome = await recordReply({ participant: { id: participant.id }, answer }, 
+        // The whole fact, not the commit alone. Spreading half of
+        // it here was how the collect path went on stamping the
+        // change's head on findings harvested off a round that had
+        // read something else, which is the path most likely to be
+        // unpinned in the first place.
+        { runId: run.id, ...whatItRead(run) }, deps, warnings);
+        // Held straight away, so the next turn of this loop cannot
+        // lose what this one paid for.
+        held.set(outcome.participantId, outcome);
+        try {
+            await deps.progressed?.({ ...run, outcomes: [...held.values()] });
+        }
+        catch {
+            // The findings are recorded either way. A ledger that will
+            // not take an interim write is reported once at the end
+            // rather than seven times from in here.
+        }
+        return outcome;
+    }, (outcome) => ({
+        participantId: outcome.participantId,
+        findings: outcome.findingIds.length,
+    }), deps.progress);
+    // Collecting a round is what finishing it means, so the mark comes
+    // off. Leaving it would keep the alarm up for work that has now
+    // been recovered, and an alarm nobody can answer stops being read.
+    //
+    // Unless nothing was recovered. Settling then closes the file on a
+    // round whose work may be sitting somewhere else entirely, and the
+    // mark is one-way: nothing sets it again. The likeliest cause of
+    // finding nothing is looking in the wrong place, a different state
+    // directory or another machine, which is exactly when the record
+    // has to survive.
+    if (answers.size === 0) {
+        return {
+            run: { ...run, outcomes },
+            warnings: [
+                ...warnings,
+                `Nothing was found on disk for any of the ${run.participants.length} participants, so ${run.id} is left open rather than settled. Its transcripts may have been swept, or may be under a different state directory or on another machine.`,
+            ],
+        };
+    }
+    const { open: _settled, ...rest } = run;
+    return { run: { ...rest, outcomes }, warnings };
+}

package/dist/review/ask/council.d.ts

@@ -0,0 +1,290 @@
+/**
+ * Asking a whole roster at once.
+ *
+ * Participants are asked concurrently, because the wait is the whole
+ * cost and there is no reason for six models to queue. Their
+ * findings are recorded **in roster order** regardless of who
+ * answered first, because people say finding numbers out loud and a
+ * number that depends on which model happened to be quickest would
+ * make the same run describe itself differently every time.
+ *
+ * Nothing one participant does can take the round down. A failure
+ * reported by the runner and an exception thrown by it are the same
+ * event seen from two sides, and both are recorded against that
+ * participant so the rest of the round survives. Losing five good
+ * reviews to one unavailable model would be the worst possible
+ * trade, given what a round costs to run.
+ */
+import type { Finding } from "../finding.js";
+import { type Participant } from "./identity.js";
+import { type AskProgress } from "./progress.js";
+import type { Roster } from "./roster.js";
+import { type AskRound, type AskRun, type AskUsage, type ParticipantOutcome, type RoundGiven } from "./run.js";
+/**
+ * Which limit ended a reviewer before it had finished.
+ *
+ * A limit is not a failure. The reviewer was working, and something
+ * on our side decided it had worked long enough, so the two are
+ * reported apart: a failure is the run never happening, and a stop
+ * is the run being taken away mid-sentence.
+ */
+export type AskLimit = "wall-clock" | "idle"
+/**
+ * Stopped inside its own budget, deliberately, so what it had
+ * could be asked for while there was still time to answer.
+ *
+ * The only limit here that is not something running out. The
+ * others describe a reviewer that was taken away; this one
+ * describes one that was asked.
+ */
+ | "soft-deadline" | "cancelled" | "parent-exit"
+/**
+ * The process watching this reviewer went away mid-review.
+ *
+ * Distinct from parent-exit, which is the session above the
+ * supervisor going away while the supervisor lived to say so.
+ * Here the supervisor itself is what vanished, so nothing was
+ * written down about the ending and this is reconstructed from
+ * the reviewer's own journal being there with no result beside
+ * it. Nothing about a budget ran out, so no clock is quoted and
+ * the retry it permits is worth taking.
+ */
+ | "supervisor-lost";
+/** A reviewer stopped before it finished, and what stopped it. */
+export interface AskStop {
+    limit: AskLimit;
+    /** What happened, in the runner's own words. */
+    detail: string;
+    /**
+     * The budget it ran out of, where the limit is a clock.
+     *
+     * Recorded so a later retry can tell whether anything has moved.
+     * Without the number, the only way to find out whether asking
+     * again would hit the same wall is to ask again and watch.
+     */
+    budgetMs?: number;
+}
+/** What came back from asking one participant. */
+export type AskAnswer = {
+    text: string;
+    usage?: AskUsage;
+    stopped?: AskStop;
+    /**
+     * What this participant had said before it was stopped, when
+     * the answer above is one it gave afterwards.
+     *
+     * Two answers rather than one joined, because only a reader
+     * that can count findings knows which is worth keeping, and
+     * joining them makes both unreadable.
+     */
+    earlierText?: string;
+    /**
+     * Findings this participant wrote down as it found them,
+     * rather than saving them for its answer.
+     *
+     * On the wire, unread, because reading one is this module's
+     * job and the thing that collected them cannot make a finding
+     * without knowing whose round it is.
+     */
+    recorded?: unknown[];
+    /**
+     * What went wrong that this answer cannot show for itself.
+     *
+     * A run can produce findings and still have gone badly: the
+     * process died after recording them, or its journal came
+     * back capped or unreadable. Neither is a failure, since
+     * there is an answer to read, and neither is visible in the
+     * answer. Without somewhere to put them the diagnosis is
+     * lost at this seam and a dead reviewer reads as a clean
+     * pass.
+     */
+    notes?: string[];
+    /** Where the answer was kept, when the runner kept it. */
+    answerPath?: string;
+} | {
+    failure: string;
+    /**
+     * Something true of the session rather than of this
+     * participant, which the runner knew and this cannot.
+     *
+     * A stale pi install is the case it exists for: every
+     * reviewer fails with the same sentence, retrying is the one
+     * thing that cannot work, and only the side that spawned the
+     * process can tell that from an ordinary crash. Carried as a
+     * fact the runner states rather than left for a reader to
+     * infer from the shape of a message: matching on words means
+     * one library string-matching another's prose, and both are
+     * free to reword.
+     */
+    advisory?: string;
+    /**
+     * What it burned before it failed.
+     *
+     * A failure is not a free participant, and is usually the
+     * dearest one in the round: a reviewer that died at its
+     * deadline spent the whole budget to produce nothing. Dropped
+     * here, a round's cost is a total with its largest terms
+     * missing, which is worse than no total at all.
+     */
+    usage?: AskUsage;
+};
+/**
+ * What a round can tell a runner about itself.
+ *
+ * The runner is the thing that leaves artifacts behind, and it cannot
+ * work out which round it belongs to on its own. A transcript that
+ * cannot be traced back to the round that paid for it answers none of
+ * the questions a transcript is kept for.
+ */
+export interface AskContext {
+    /** The round this ask belongs to, as the ledger names it. */
+    runId: string;
+    /**
+     * How a long-running ask says what it is doing. Optional to call
+     * and optional to receive: the library cannot see a subprocess, so
+     * activity only exists if the implementation volunteers it.
+     */
+    report?(activity: string): void;
+}
+/**
+ * Run one participant against the prompt, for a named round.
+ *
+ * Named once and shared by every round's deps. Each used to restate
+ * the signature, which is how two of them still had a bare report
+ * callback after the context arrived.
+ */
+export type Ask = (participant: Participant, prompt: string, context: AskContext) => Promise<AskAnswer>;
+/** The impure things asking needs. */
+export interface CouncilDeps {
+    ask: Ask;
+    /** Put findings on the change, numbering them as they land. */
+    record(findings: Omit<Finding, "id">[]): Promise<Finding[]>;
+    now(): Date;
+    /**
+     * The round exists and nobody has been asked yet.
+     *
+     * Called once, before the first reviewer is dispatched, so a
+     * caller that keeps a ledger can write the round down before it
+     * becomes expensive rather than after it has already paid.
+     * Optional, because a round is worth more than the bookkeeping
+     * around it and most callers keep no ledger at all.
+     */
+    opened?(run: AskRun): Promise<void>;
+    /** Told what is happening while it happens. Optional. */
+    progress?: AskProgress;
+}
+/** What to ask, of whom. */
+export interface CouncilRequest {
+    roster: Roster;
+    prompt: string;
+    /** Distinguishes two rounds started in the same millisecond. */
+    seq: number;
+    /** Commit under review, which anchors claim when the tree is it. */
+    witness?: string;
+    /** Said when the tree the reviewers read was not that commit. */
+    unpinned?: string;
+    /** What the reviewers were handed, besides the change. */
+    given?: RoundGiven;
+    /** Defaults to a council round. */
+    round?: AskRound;
+}
+/** The run, and anything worth telling the caller. */
+export interface CouncilResult {
+    run: AskRun;
+    warnings: string[];
+}
+/** What one participant came back with, before it was recorded. */
+export interface Reply {
+    participant: Participant;
+    answer: AskAnswer;
+}
+/**
+ * Ask every reviewer at once and hand the answers back in roster
+ * order.
+ *
+ * Shared with the stack round rather than written twice, because this
+ * is the part with the rules in it: concurrent asking, a thrown error
+ * and a reported one becoming the same thing, and the ordering that
+ * makes finding numbers stable. A stack round differs in what a reply
+ * *means*, not in how a roster is asked, and if the ordering rule ever
+ * changes both rounds have to change with it.
+ */
+export declare function askRoster(roster: Roster, prompt: string, runId: string, deps: Pick<CouncilDeps, "ask" | "progress">): Promise<Reply[]>;
+/**
+ * Ask one participant, reported the same way a roster is.
+ *
+ * A round with a single participant is still a round somebody is waiting
+ * on, and the wait is no shorter for being one subagent: a judge
+ * consolidating sixty findings takes as long as the council that raised
+ * them. Reporting was left to each round to remember, and the judge did
+ * not, so it ran to completion showing nothing at all.
+ *
+ * Beside `askRoster` rather than inside it, because a fan-out of one is
+ * not what this is: there is no ordering rule to share and no concurrency
+ * to arrange. What the two have in common is the beats they report, and
+ * this is the place that says what those are for one participant.
+ */
+export declare function askOne(participant: Participant, prompt: string, runId: string, deps: Pick<CouncilDeps, "ask" | "progress">): Promise<AskAnswer>;
+/** Ask a roster about a change and record what it says. */
+export declare function runCouncil(request: CouncilRequest, deps: CouncilDeps): Promise<CouncilResult>;
+/**
+ * A round at the moment it exists and nobody has been asked.
+ *
+ * Shared by the runner that waits for a round and the one that walks
+ * away from it, because a round's identity is one concept and two
+ * copies of it would drift. A detached round is collected back into
+ * the same listing as a live one, so an id minted differently, or a
+ * participant identified differently, would show up as two kinds of
+ * round rather than one round run two ways.
+ */
+export declare function openingRun(request: CouncilRequest, startedAt: Date): AskRun;
+/**
+ * What was thrown, said well enough to act on.
+ *
+ * A failure a runner reports is a sentence somebody wrote for a
+ * person, and it is left exactly as it is. A failure that was thrown
+ * is usually nobody's sentence: it is a message the runtime wrote,
+ * and on its own it does not say what kind of fault it was or where
+ * it happened.
+ *
+ * Measured, on a council that lost all seven reviewers to one
+ * TypeError. The ledger held "Cannot read properties of undefined
+ * (reading 'split')" and nothing else, which is true of every call to
+ * split in the dispatch path, so the diagnosis was an afternoon of
+ * reading them. The round is the expensive thing here and the ledger
+ * is what survives it, so the ledger has to carry enough to name the
+ * line.
+ *
+ * One frame, not the whole stack. The rest is this file's own
+ * machinery on every occasion, and a ledger entry is read in a table.
+ *
+ * A cause is carried when there is one. An error wrapped in another
+ * says the same little as the message this exists to improve on: the
+ * outer sentence names the layer that gave up and the inner one names
+ * what actually happened.
+ */
+export declare function thrownAt(error: unknown): string;
+/**
+ * What to say about a participant that did not get to finish.
+ *
+ * Shared with the stack round, which is the round most likely to be
+ * stopped and was saying nothing about it at all: it pushed the
+ * harvest's own warnings through, so a reviewer we interrupted was
+ * reported as having written a malformed answer.
+ */
+export declare function stopWarning(stop: AskStop, kept: number, cutOff: boolean): string;
+/**
+ * Harvest one reply, record what it held, and say how it went.
+ *
+ * Shared with collecting a round afterwards rather than written
+ * twice, because this is the part with the rules in it: reading a
+ * fragment against a wrap-up, folding in what was recorded, and
+ * deciding which warnings belong to the reviewer rather than to our
+ * deadline. A collected answer is the same answer arriving late, and
+ * a second copy of these rules would drift from this one.
+ */
+export declare function recordReply(reply: Reply, run: {
+    runId: string;
+    witness?: string;
+    unpinned?: string;
+}, deps: Pick<CouncilDeps, "record">, warnings: string[]): Promise<ParticipantOutcome>;