@popoverai/dotrequirements 0.32.1 → 0.34.0

package/dist/convex.d.ts

@@ -17,13 +17,14 @@
 export declare const api: {
     documents: {
         queries: {
-            exportForCli: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
-            exportProjectForCli: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
-            checkDocumentsExist: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            exportDocument: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            exportProject: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            exportProjectForShare: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            foreignDocumentIds: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
         mutations: {
-            deleteForCli: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
-            setAttachmentsForSync: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            deleteForSync: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            syncAttachments: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
         saveWithRequirements: {
             saveWithRequirements: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
@@ -37,7 +38,7 @@ export declare const api: {
     projects: {
         mutations: {
             create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
-            update: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            updateProject: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
     };
     teams: {
@@ -53,19 +54,72 @@ export declare const api: {
             getInviteInfo: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
         mutations: {
-            createInvite: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            createInviteLink: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
             acceptInvite: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
         };
     };
     projectSecrets: {
         queries: {
             getOwnSecret: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
-            listOwnSecretsForTeam: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            listOwnForTeam: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
         mutations: {
-            ensureOwnSecret: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            ensureOwn: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
             revokeOwnSecret: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
-            ensureShareToken: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            ensureProjectShareToken: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+    };
+    scores: {
+        mutations: {
+            create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            update: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+    };
+    mockups: {
+        mutations: {
+            create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+    };
+    solutions: {
+        queries: {
+            getPlan: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getThread: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getThings: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            defaultPlan: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            readPlanFile: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getOutcomePage: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            getAgentLogs: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            forSync: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            rehearsalsOf: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            rehearsalHistory: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+        };
+        mutations: {
+            create: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            start: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            next: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            complete: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            ask: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            stall: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            answer: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            approveCheckpoint: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            removeRehearsal: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            videoUploadUrl: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+        shares: {
+            forCheckout: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            push: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            done: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+        };
+        images: {
+            uploadUrl: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            inputUploadUrl: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            copies: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+        };
+        branches: {
+            branchOf: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
+            claim: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            recordPush: import("convex/server").FunctionReference<"mutation", "public", any, any, string | undefined>;
+            removal: import("convex/server").FunctionReference<"query", "public", any, any, string | undefined>;
         };
     };
     lib: {

package/dist/convex.js

@@ -21,15 +21,18 @@ const action = (name) => makeFunctionReference(name);
 export const api = {
     documents: {
         queries: {
-            exportForCli: query("documents/queries:exportForCli"),
-            exportProjectForCli: query("documents/queries:exportProjectForCli"),
-            checkDocumentsExist: query("documents/queries:checkDocumentsExist"),
+            exportDocument: query("documents/queries:exportDocument"),
+            exportProject: query("documents/queries:exportProject"),
+            // SHARE-TOKEN-3: the same export for a read-only share token
+            exportProjectForShare: query("documents/queries:exportProjectForShare"),
+            // SYNC-FAIL-5: which of the workspace's ids name another project's document
+            foreignDocumentIds: query("documents/queries:foreignDocumentIds"),
         },
         mutations: {
             // SYNC-MODE-3: delete a cloud document from the CLI (repo-wins)
-            deleteForCli: mutation("documents/mutations:deleteForCli"),
+            deleteForSync: mutation("documents/mutations:deleteForSync"),
             // ATTACH-10.2: attachment-only sync — a metadata patch, never a publish
-            setAttachmentsForSync: mutation("documents/mutations:setAttachmentsForSync"),
+            syncAttachments: mutation("documents/mutations:syncAttachments"),
         },
         // SYNC-ARCH-1: Save document with requirements derivation
         saveWithRequirements: {
@@ -44,7 +47,7 @@ export const api = {
     projects: {
         mutations: {
             create: mutation("projects/mutations:create"),
-            update: mutation("projects/mutations:update"),
+            updateProject: mutation("projects/mutations:updateProject"),
         },
     },
     teams: {
@@ -60,7 +63,7 @@ export const api = {
             getInviteInfo: query("teamInvites/queries:getInviteInfo"),
         },
         mutations: {
-            createInvite: mutation("teamInvites/mutations:createInvite"),
+            createInviteLink: mutation("teamInvites/mutations:createInviteLink"),
             // Joins the team and reconciles paid-team seats via a scheduled sync
             // (POLAR-SEATS-3). Replaced the deleted polar:acceptTeamInvite action.
             acceptInvite: mutation("teamInvites/mutations:acceptInvite"),
@@ -69,12 +72,74 @@ export const api = {
     projectSecrets: {
         queries: {
             getOwnSecret: query("projectSecrets/queries:getOwnSecret"),
-            listOwnSecretsForTeam: query("projectSecrets/queries:listOwnSecretsForTeam"),
+            listOwnForTeam: query("projectSecrets/queries:listOwnForTeam"),
         },
         mutations: {
-            ensureOwnSecret: mutation("projectSecrets/mutations:ensureOwnSecret"),
+            ensureOwn: mutation("projectSecrets/mutations:ensureOwn"),
             revokeOwnSecret: mutation("projectSecrets/mutations:revokeOwnSecret"),
-            ensureShareToken: mutation("projectSecrets/mutations:ensureShareToken"),
+            ensureProjectShareToken: mutation("projectSecrets/mutations:ensureProjectShareToken"),
+        },
+    },
+    // VERB-7: scores made and revised from the shell, submitted as scores:<id>
+    scores: {
+        mutations: {
+            create: mutation("scores/mutations:create"),
+            update: mutation("scores/mutations:update"),
+        },
+    },
+    mockups: {
+        mutations: {
+            create: mutation("mockups/mutations:create"),
+        },
+    },
+    solutions: {
+        queries: {
+            getPlan: query("solutions/queries:getPlan"),
+            getThread: query("solutions/queries:getThread"),
+            getThings: query("solutions/queries:getThings"),
+            defaultPlan: query("solutions/queries:defaultPlan"),
+            readPlanFile: query("solutions/queries:readPlanFile"),
+            // An outcome's page: where it stands, and the decision open on it.
+            getOutcomePage: query("solutions/queries:getOutcomePage"),
+            getAgentLogs: query("solutions/queries:getAgentLogs"),
+            forSync: query("solutions/queries:forSync"),
+            rehearsalsOf: query("solutions/queries:rehearsalsOf"),
+            rehearsalHistory: query("solutions/queries:rehearsalHistory"),
+        },
+        mutations: {
+            create: mutation("solutions/mutations:create"),
+            start: mutation("solutions/mutations:start"),
+            next: mutation("solutions/mutations:next"),
+            complete: mutation("solutions/mutations:complete"),
+            ask: mutation("solutions/mutations:ask"),
+            stall: mutation("solutions/mutations:stall"),
+            answer: mutation("solutions/mutations:answer"),
+            // A rehearsal's scripted approval of a checkpoint (CHECKPOINT-1.1).
+            approveCheckpoint: mutation("solutions/mutations:approveCheckpoint"),
+            removeRehearsal: mutation("solutions/mutations:removeRehearsal"),
+            // SIGHT-7.0: where a video is uploaded before it is submitted
+            videoUploadUrl: mutation("solutions/mutations:videoUploadUrl"),
+        },
+        // SOLSHARE: a solution's share command, on its token alone.
+        shares: {
+            forCheckout: query("solutions/shares:forCheckout"),
+            push: mutation("solutions/shares:push"),
+            done: mutation("solutions/shares:done"),
+        },
+        // SIGHT-9: where an image is uploaded before it is submitted, and where
+        // the copies an outcome works on are fetched from.
+        images: {
+            uploadUrl: mutation("solutions/images:uploadUrl"),
+            // REHEARSE-4.7: an image a scenario names for an input, before the solution exists
+            inputUploadUrl: mutation("solutions/images:inputUploadUrl"),
+            copies: query("solutions/images:copies"),
+        },
+        // SOLBRANCH, REHEARSE-6.7: a solution's branch and its pushes.
+        branches: {
+            branchOf: query("solutions/branches:branchOf"),
+            claim: mutation("solutions/branches:claim"),
+            recordPush: mutation("solutions/branches:recordPush"),
+            removal: query("solutions/branches:removal"),
         },
     },
     lib: {

package/dist/harness/finalize.js

@@ -11,8 +11,10 @@
  */
 import { execSync } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import { convexUrl } from "../cloud.js";
 import { canonicalRequirementPath } from "../schema/index.js";
 import { getProjectInfo } from "../utils/project-settings.js";
+import { enableVersionMessages, formatVersionMessages, markVersionMessagesShown, versionMessages, } from "../version-messages.js";
 import { cleanupTestRunId, clearCoverageReportFailure, deleteTrackingFile, findProjectRoot, findRequirementsDir, getTestRunId, needsReporting, readCoverageCache, readLookupCache, readTrackingEntries, recordCoverageReplayed, recordCoverageReported, recordCoverageReportFailure, updateCoverageCache, } from "./cache.js";
 import { formatFailureNotice, formatUnrecordedNotice, refusalReason, } from "./reportingStatus.js";
 import { toProjectRelativePath } from "./tracking.js";
@@ -130,10 +132,6 @@ function printLocalReport(testedKeys, lookup, options) {
         console.log(report);
     }
 }
-/**
- * Production Convex deployment URL
- */
-const CONVEX_URL = "https://data.dotrequirements.io";
 /**
  * Record a reporting attempt that did not reach the cloud, so later runs and
  * `dotreq report` keep saying so (COVERAGE-REPORT-3), and hand the reason back
@@ -190,18 +188,18 @@ const REPORT_TIMEOUT_MS = 15_000;
  */
 async function postCoverage(credentials, report) {
     // Note: projectId from env is always a slug (e.g., "reduced-cephalopod-288"),
-    // not a Convex ID. Use projectSlug field for authentication and slug for target.
-    const response = await fetch(`${CONVEX_URL}/api/mutation`, {
+    // not a Convex ID. It names the project both to authenticate and as the report's project.
+    const response = await fetch(`${convexUrl()}/api/mutation`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-            path: "testCoverage/mutations:recordCoverage",
+            path: "testCoverage/mutations:record",
             args: {
                 projectAuth: {
                     projectSlug: credentials.projectId,
                     projectSecret: credentials.projectSecret,
                 },
-                target: { type: "project", slug: credentials.projectId },
+                project: credentials.projectId,
                 branch: report.branch,
                 context: report.context,
                 runId: report.runId,
@@ -528,6 +526,9 @@ export async function finalize(options = {}) {
         count: 0,
     };
     if (shouldReportToCloud) {
+        // CLI-MSG-1.4: a run that reports to the cloud hears what it has to say
+        // to this version.
+        enableVersionMessages();
         cloudResult = await reportToConvex(projectRoot, testRunId, aggregated, showCloudStatus, context);
     }
     // Read once, after reporting has had its say, for both the report header and
@@ -551,6 +552,13 @@ export async function finalize(options = {}) {
                 (recordedThisRun ? null : coverageCache?.lastFailure)),
         });
     }
+    // CLI-MSG-1.4: the summary closes with the cloud's messages for this
+    // version — ahead of the notice below, which keeps the last word.
+    const messages = await versionMessages();
+    if (messages.length > 0) {
+        console.error(`${formatVersionMessages(messages)}\n`);
+    }
+    markVersionMessagesShown();
     // COVERAGE-REPORT-2.1, -3.0: the run's last word is whether coverage
     // recorded. Written to stderr so it cannot be silenced by a quiet run or
     // swallowed by a caller parsing stdout — a failure nobody sees is the whole

package/dist/harness/reportingStatus.js

@@ -5,6 +5,7 @@
  * COVERAGE-REPORT-2 / -3 (the run says coverage did not record, and keeps
  * saying it until it does).
  */
+import { userFacingMessage } from "../utils/command-error.js";
 /**
  * Shown when a refusal carries nothing a developer could act on
  * (COVERAGE-REPORT-1.2). The raw `errorMessage` is deliberately not used in its
@@ -19,17 +20,7 @@ export const REFUSAL_WITHOUT_REASON = "the cloud refused the report without givi
  * ConvexError's data is either a plain string or an object carrying `message`.
  */
 export function refusalReason(response) {
-    const data = response.errorData;
-    if (typeof data === "string" && data.trim()) {
-        return data;
-    }
-    if (data && typeof data === "object" && "message" in data) {
-        const { message } = data;
-        if (typeof message === "string" && message.trim()) {
-            return message;
-        }
-    }
-    return REFUSAL_WITHOUT_REASON;
+    return userFacingMessage(response.errorData) ?? REFUSAL_WITHOUT_REASON;
 }
 const MONTHS = [
     "January",

package/dist/push/core.js

@@ -35,8 +35,13 @@ export function parseFilesForPush(filePaths) {
     for (const filePath of filePaths) {
         // Read raw file content
         const rawContent = fs.readFileSync(filePath, "utf-8");
-        // Parse to get metadata and requirements
-        const parsed = parseRequirementsFromFile(filePath);
+        // Parse to get metadata and requirements. A file without the
+        // `.requirements.md` name is a solution's other document (SOLDOC-3): it
+        // has no requirement blocks, maybe no frontmatter yet, and is still a
+        // document.
+        const parsed = parseRequirementsFromFile(filePath, {
+            solutionDocument: !filePath.endsWith(".requirements.md"),
+        });
         const flatRequirements = getAllRequirements(parsed.requirements);
         // Extract markdown content (everything after frontmatter)
         const markdownContent = extractMarkdownContent(rawContent);

package/dist/rehearsal/derive.d.ts

@@ -0,0 +1,23 @@
+import type { Plan, PlanPart } from "./types.js";
+/**
+ * Some of a plan's outcomes given their inputs (REHEARSE-1.0, 1.6, 1.8):
+ * the smallest plan holding those outcomes, in the plan's order and
+ * phases, whose inputs are what they await, are against or are on that
+ * none of them is, so they run as if the outcomes before them were made.
+ * So a scenario naming Scores alone, of the default plan, runs the scores
+ * with the pitch an input. An outcome on one left out is kept on that
+ * one's surface instead. The checkpoints on what is kept stay, presenting
+ * what is still there; loops go, since part of a plan starts or ends
+ * nothing.
+ *
+ * The one exception is the outcome that makes the solution exist: the
+ * plan's first outcome when the person makes it at creation, with an agent
+ * (the Idea in the default plan, which is the solution itself). When a
+ * chosen outcome works from it, it is kept at the head of the derived plan,
+ * so the solution is the idea there as in production, and the scenario
+ * names nothing for it.
+ */
+export declare function planForOutcomes(plan: Plan, names: readonly string[]): Plan;
+/** The plan a scenario names: the whole one, or some of its outcomes derived from it. */
+export declare function planOf(plan: Plan | PlanPart): Plan;
+//# sourceMappingURL=derive.d.ts.map

package/dist/rehearsal/derive.js

@@ -0,0 +1,112 @@
+/** Every outcome in the plan, in its order. */
+const outcomesOf = (plan) => plan.phases.flatMap((phase) => phase.outcomes);
+/** The surface an outcome is kept on: its own, or the one the outcome it is on is kept on. */
+function surfaceOf(plan, name) {
+    const seen = new Set();
+    let current = name;
+    for (;;) {
+        if (seen.has(current))
+            return undefined;
+        seen.add(current);
+        const outcome = outcomesOf(plan).find((each) => each.name === current);
+        if (!outcome) {
+            return plan.surfaces.find((surface) => surface.name === current)?.name;
+        }
+        if (plan.surfaces.some((surface) => surface.name === outcome.on)) {
+            return outcome.on;
+        }
+        current = outcome.on;
+    }
+}
+/** What an outcome waits on or works from: what it and its review await, what it is against, and the outcome it is on. */
+const worksFrom = (plan, outcome) => [
+    ...(outcome.awaits ?? []),
+    ...(outcome.reviewAwaits ?? []),
+    ...(outcome.against ?? []),
+    ...(outcomesOf(plan).some((each) => each.name === outcome.on)
+        ? [outcome.on]
+        : []),
+];
+/**
+ * Some of a plan's outcomes given their inputs (REHEARSE-1.0, 1.6, 1.8):
+ * the smallest plan holding those outcomes, in the plan's order and
+ * phases, whose inputs are what they await, are against or are on that
+ * none of them is, so they run as if the outcomes before them were made.
+ * So a scenario naming Scores alone, of the default plan, runs the scores
+ * with the pitch an input. An outcome on one left out is kept on that
+ * one's surface instead. The checkpoints on what is kept stay, presenting
+ * what is still there; loops go, since part of a plan starts or ends
+ * nothing.
+ *
+ * The one exception is the outcome that makes the solution exist: the
+ * plan's first outcome when the person makes it at creation, with an agent
+ * (the Idea in the default plan, which is the solution itself). When a
+ * chosen outcome works from it, it is kept at the head of the derived plan,
+ * so the solution is the idea there as in production, and the scenario
+ * names nothing for it.
+ */
+export function planForOutcomes(plan, names) {
+    const all = outcomesOf(plan);
+    for (const name of names) {
+        if (!all.some((outcome) => outcome.name === name)) {
+            throw new Error(`The plan has no outcome called "${name}". Its outcomes: ${all.map((outcome) => outcome.name).join(", ")}.`);
+        }
+    }
+    const chosen = new Set(names);
+    const first = all[0];
+    const creation = first?.createdWith !== undefined && !chosen.has(first.name)
+        ? first
+        : undefined;
+    const picked = all.filter((outcome) => chosen.has(outcome.name));
+    const needed = [
+        ...new Set(picked.flatMap((outcome) => worksFrom(plan, outcome))),
+    ].filter((name) => !chosen.has(name));
+    const keepsCreation = !!creation && needed.includes(creation.name);
+    const kept = new Set([
+        ...chosen,
+        ...(keepsCreation && creation ? [creation.name] : []),
+    ]);
+    const inputs = [
+        ...plan.inputs.filter((name) => needed.includes(name)),
+        ...all
+            .map((outcome) => outcome.name)
+            .filter((name) => needed.includes(name) && !kept.has(name)),
+    ];
+    const phases = plan.phases.flatMap((phase) => {
+        const outcomes = phase.outcomes
+            .filter((outcome) => kept.has(outcome.name))
+            .map((outcome) => 
+        // On an outcome left out, it is kept on that one's surface.
+        all.some((each) => each.name === outcome.on) && !kept.has(outcome.on)
+            ? { ...outcome, on: surfaceOf(plan, outcome.on) ?? outcome.on }
+            : outcome);
+        return outcomes.length > 0 ? [{ ...phase, outcomes }] : [];
+    });
+    const known = new Set([...kept, ...inputs]);
+    const keptOn = (on) => kept.has(on) ||
+        [...kept].some((name) => surfaceOf(plan, name) === on && name !== on);
+    const checkpoints = plan.checkpoints.flatMap((checkpoint) => {
+        if (!keptOn(checkpoint.on))
+            return [];
+        if (!checkpoint.presents?.length)
+            return [checkpoint];
+        const presents = checkpoint.presents.filter((name) => known.has(name));
+        return presents.length > 0 ? [{ ...checkpoint, presents }] : [];
+    });
+    return {
+        format: "outcomes",
+        inputs,
+        surfaces: plan.surfaces,
+        phases,
+        checkpoints,
+        agents: plan.agents,
+        loops: [],
+    };
+}
+/** The plan a scenario names: the whole one, or some of its outcomes derived from it. */
+export function planOf(plan) {
+    if (!("from" in plan))
+        return plan;
+    return planForOutcomes(plan.from, plan.outcomes);
+}
+//# sourceMappingURL=derive.js.map

package/dist/rehearsal/driver.d.ts

@@ -0,0 +1,44 @@
+import type { Party, Plan, RehearsalClient, RehearsalReport, Scenario } from "./types.js";
+/**
+ * The plan a scenario rehearses, refused when it names an outcome the plan
+ * doesn't have or leaves one of its inputs holding nothing: what a live
+ * rehearsal checks before it removes the scenario's earlier runs, so a
+ * mistake in the scenario never costs the run under review. An input the
+ * scenario doesn't name holds something when the earlier rehearsal it
+ * starts from holds it (REHEARSE-4.8).
+ */
+export declare function checkScenario(scenario: Scenario): Plan;
+/** A part of an outcome's work: drafting it, reviewing it, or, with no agent, making it from outside. */
+export type Part = {
+    outcome: string;
+    part: "draft" | "review" | "outside";
+    /** The agent; absent for an outcome someone outside, or the owner with an agent, makes. */
+    agent?: string;
+    /** Who makes it from outside, when the panel says. */
+    party?: string;
+};
+/**
+ * Who plays an agent at a part of an outcome's work in a scenario: the key
+ * naming that agent on that outcome (`Code/Code Reviewer`), then the key
+ * naming the part — the outcome's name for its drafter or whoever makes it
+ * from outside (`Pitch`), "<outcome>/reviewer" for its reviewers
+ * (`Pitch/reviewer`) — then the agent's own name (`Acceptance Tester`, or
+ * `Pitch/drafter` for one dedicated to its outcome), then whoever outside
+ * makes it (`release manager`). Unnamed, an agent is real. The key that
+ * matched, for counting turns.
+ */
+export declare function partiesOf(parties: Scenario["parties"]): (at: Part) => {
+    party: Party;
+    key: string;
+};
+/**
+ * The driver (docs/working/rehearsing-steps.md): the orchestrator the
+ * product has as events, as a loop. Look at where every outcome stands;
+ * for each part of the work due, find who plays its agent; play a script
+ * through the same verbs an agent uses — `next` for the agent, then what
+ * its script records — or wait for a real one; answer decisions and
+ * checkpoints from the person's script; stop when nothing is ready, or
+ * when something needs a person nobody scripted, or an agent stalls.
+ */
+export declare function rehearse(client: RehearsalClient, scenario: Scenario): Promise<RehearsalReport>;
+//# sourceMappingURL=driver.d.ts.map