@popoverai/dotrequirements 0.33.0 → 0.34.1

package/README.md

@@ -251,13 +251,13 @@ Browser testing needs a Stagehand model and the API key for that model's provide
 {
   "defaultURL": "https://your-app.com",
   "browserTest": {
-    "modelName": "gateway/anthropic/claude-haiku-4-5",
+    "modelName": "gateway/anthropic/claude-haiku-5.5",
     "modelApiKey": "your-api-key"
   }
 }
 ```
 
-Pick any Stagehand-supported model. Example values: `gateway/anthropic/claude-haiku-4-5` (Vercel AI Gateway key), `google/gemini-3-flash-preview` (Gemini key).
+Pick any Stagehand-supported model. Example values: `gateway/anthropic/claude-haiku-5.5` (Vercel AI Gateway key), `google/gemini-3-flash-preview` (Gemini key).
 
 Optional settings: `vercelBypassSecret`, `browserbaseApiKey`, `browserbaseProjectId`. Setting both Browserbase fields switches runs from LOCAL (spawns Playwright on your machine) to BROWSERBASE (managed cloud browsers).
 

package/dist/cli.js

@@ -2,10 +2,11 @@
 import { readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { Command } from "commander";
+import { Command, Option } from "commander";
 import { acceptanceTestCommand } from "./commands/acceptance-test.js";
 import { aiSetupCommand } from "./commands/ai-setup.js";
 import { pullAlias, pushAlias } from "./commands/aliases.js";
+import { registerBoard } from "./commands/board/index.js";
 import { registerCodebaseToSpec } from "./commands/codebase-to-spec/index.js";
 import { createRequirementDocumentCommand } from "./commands/create-requirement-document.js";
 import { diffCommand } from "./commands/diff.js";
@@ -16,11 +17,14 @@ import { initCommand } from "./commands/init.js";
 import { linkCommand } from "./commands/link.js";
 import { listCommand } from "./commands/list.js";
 import { mcpCommand } from "./commands/mcp.js";
+import { registerMockup } from "./commands/mockup/index.js";
 import { prepareCommand } from "./commands/prepare.js";
 import { reportCommand } from "./commands/report.js";
 import { requirementsForCommand } from "./commands/requirements-for.js";
 import { reviewTestCommand } from "./commands/review-test.js";
+import { registerScores } from "./commands/scores/index.js";
 import { searchCommand } from "./commands/search.js";
+import { registerSolution } from "./commands/solution/index.js";
 import { styleCheckCommand } from "./commands/style-check.js";
 import { syncCliAction } from "./commands/sync.js";
 import { testsForCommand } from "./commands/tests-for.js";
@@ -115,6 +119,10 @@ program
     .option("-s, --share <token>", "Read-only share token (no setup required)")
     .option("-p, --project <id>", "Override the project slug")
     .option("-y, --yes", "Skip the deletion confirmation prompt")
+    // BRANCH-8: merging a solution's branch into main. Kept out of --help, as
+    // the solution verbs are, until the solution flow is offered.
+    .addOption(new Option("--branch-contributes <solution-id>", "Merge the solution's branch into main: its additions only").hideHelp())
+    .addOption(new Option("--branch-wins <solution-id>", "Merge the solution's branch into main: the branch overwrites what differs").hideHelp())
     .action(wrapCommand(syncCliAction));
 // Deprecated aliases into `sync`, kept for commands already in the wild
 // (SYNC-ALIAS-1). Each prints a deprecation notice naming its new spelling.
@@ -225,5 +233,9 @@ program
     .description("Print the greenfield interview protocol — for working out what something new should do before writing its spec")
     .action(wrapCommand(greenfieldDiscoveryCommand));
 registerCodebaseToSpec(program);
+registerSolution(program);
+registerMockup(program);
+registerBoard(program);
+registerScores(program);
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/cloud.d.ts

@@ -5,7 +5,11 @@
  */
 /** The web app, home of the hosted AI endpoints and publishing. */
 export declare const DEFAULT_API_BASE_URL = "https://app.dotrequirements.io";
-/** The Convex backend's address, for a ConvexHttpClient or its HTTP API. */
+/**
+ * The Convex backend's address, for a ConvexHttpClient or its HTTP API:
+ * production, unless DOTREQ_CONVEX_URL points somewhere else, such as a dev
+ * or preview deployment.
+ */
 export declare function convexUrl(): string;
 /** The web app's address; `DOTREQUIREMENTS_API_URL` overrides it. */
 export declare function webApiUrl(): string;

package/dist/cloud.js

@@ -15,10 +15,14 @@ function noteUse() {
     used = true;
     onFirstUse?.();
 }
-/** The Convex backend's address, for a ConvexHttpClient or its HTTP API. */
+/**
+ * The Convex backend's address, for a ConvexHttpClient or its HTTP API:
+ * production, unless DOTREQ_CONVEX_URL points somewhere else, such as a dev
+ * or preview deployment.
+ */
 export function convexUrl() {
     noteUse();
-    return CONVEX_URL;
+    return process.env.DOTREQ_CONVEX_URL?.trim() || CONVEX_URL;
 }
 /** The web app's address; `DOTREQUIREMENTS_API_URL` overrides it. */
 export function webApiUrl() {

package/dist/commands/acceptance-test.js

@@ -52,7 +52,7 @@ export async function acceptanceTestCommand(requirementKey, url, options) {
         console.error("Error: no browser-test model configured in project-settings.json.");
         console.log("Add a block like:\n" +
             '  "browserTest": {\n' +
-            '    "modelName": "gateway/anthropic/claude-haiku-4-5",\n' +
+            '    "modelName": "gateway/anthropic/claude-haiku-5.5",\n' +
             '    "modelApiKey": "..."\n' +
             "  }\n" +
             "to .requirements/project-settings.json. See the docs for supported models.");

package/dist/commands/board/index.d.ts

@@ -0,0 +1,13 @@
+import type { Command } from "commander";
+export declare function guideCommand(): Promise<void>;
+export declare function createCommand(options: {
+    title: string;
+    description?: string;
+    file: string;
+}): Promise<void>;
+export declare function updateCommand(boardId: string, options: {
+    file: string;
+}): Promise<void>;
+export declare function showCommand(boardId: string): Promise<void>;
+export declare function registerBoard(program: Command): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/board/index.js

@@ -0,0 +1,96 @@
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { webApiUrl } from "../../cloud.js";
+import { getProjectCredentials } from "../../utils/project-settings.js";
+/**
+ * Hidden from help until solutions launch: today's users see the CLI they
+ * have now, and the server refuses these commands for a team without the
+ * solutions switch (SOLACCESS-2).
+ */
+const HIDDEN_UNTIL_LAUNCH = { hidden: true };
+async function throughApp(path, extra) {
+    const { projectId, projectSecret } = getProjectCredentials();
+    const base = webApiUrl();
+    const response = await fetch(`${base}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ projectId, projectSecret, ...extra }),
+    });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => ({})));
+        // BOARD-CLI-3: every problem at once, each on its line — an agent that
+        // gets one problem per attempt spends a turn per typo.
+        const problems = (body.problems ?? [])
+            .map((problem) => problem.line === undefined
+            ? `  ${problem.message}`
+            : `  Line ${problem.line}: ${problem.message}`)
+            .join("\n");
+        throw new Error([body.error || response.statusText, problems]
+            .filter(Boolean)
+            .join("\n"));
+    }
+    return response;
+}
+export async function guideCommand() {
+    const response = await throughApp("/api/boards/guide", {});
+    const { guide } = (await response.json());
+    process.stdout.write(`${guide}\n`);
+}
+export async function createCommand(options) {
+    const yaml = readFileSync(resolve(options.file), "utf8");
+    const response = await throughApp("/api/boards/create", {
+        title: options.title,
+        description: options.description,
+        yaml,
+    });
+    const { boardId, message } = (await response.json());
+    console.log(`Created board ${boardId}. ${message} Submit it as board:${boardId}; read it back with: dotreq board show ${boardId}`);
+}
+export async function updateCommand(boardId, options) {
+    const yaml = readFileSync(resolve(options.file), "utf8");
+    const response = await throughApp("/api/boards/update", { boardId, yaml });
+    const { message } = (await response.json());
+    console.log(message);
+}
+export async function showCommand(boardId) {
+    const response = await throughApp("/api/boards/show", { boardId });
+    const { yaml } = (await response.json());
+    process.stdout.write(yaml.endsWith("\n") ? yaml : `${yaml}\n`);
+}
+export function registerBoard(program) {
+    const board = program
+        .command("board", HIDDEN_UNTIL_LAUNCH)
+        .description("Make and read discovery boards");
+    board
+        .command("guide")
+        .description("Print the board authoring guide: the YAML a board is written in, what each verb does, a complete example")
+        .action(wrap(guideCommand));
+    board
+        .command("create")
+        .description("Create a board in the project from a YAML file")
+        .requiredOption("--title <title>", "The board's title")
+        .option("--description <text>", "What the board explores")
+        .requiredOption("--file <path>", "The board file")
+        .action(wrap(createCommand));
+    board
+        .command("update <board-id>")
+        .description("Make a board say what a YAML file says")
+        .requiredOption("--file <path>", "The board file")
+        .action(wrap(updateCommand));
+    board
+        .command("show <board-id>")
+        .description("Print a board as the YAML it is written in")
+        .action(wrap(showCommand));
+}
+function wrap(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (error) {
+            console.error(`\nError: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exitCode = 1;
+        }
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/branch-merge.d.ts

@@ -0,0 +1,78 @@
+/**
+ * `dotreq sync --branch-contributes <solution-id>` and `--branch-wins
+ * <solution-id>`: merge a solution's branch into main (BRANCH-8). Both sides
+ * are in the cloud, so no local file is read or written; the web app's merge
+ * route does it, as it does for the solution page's Merge action.
+ */
+type MergeDocument = {
+    title: string;
+    action: string;
+    because?: string;
+};
+type MergeRefusal = {
+    kind: "conflicts";
+    documents: string[];
+} | {
+    kind: "key";
+    key: string;
+    holder: string;
+    document: string;
+} | {
+    kind: "limit";
+    message: string;
+} | {
+    kind: "swap";
+    documents: string[];
+} | {
+    kind: "nothing";
+};
+type MergePlan = {
+    solution: {
+        title: string;
+    };
+    documents: MergeDocument[];
+    refusal: MergeRefusal | null;
+};
+type MergeOutcome = {
+    kind: "merged";
+    landed: string[];
+    plan: MergePlan;
+} | {
+    kind: "refused";
+    plan: MergePlan;
+} | {
+    kind: "no branch";
+} | {
+    kind: "stopped";
+    landed: string[];
+    at: string;
+    reason: string;
+    plan: MergePlan;
+};
+export type BranchMergeFlags = {
+    branchContributes?: string;
+    branchWins?: string;
+};
+/** The flags a branch merge can't be combined with (BRANCH-8.3). */
+declare const OTHER_FLAGS: readonly ["cloudContributes", "repoContributes", "cloudWins", "repoWins", "share", "project"];
+/**
+ * The merge a sync's flags ask for, or null when they ask for none. Throws,
+ * saying so, when they combine a merge with anything else (BRANCH-8.3).
+ */
+export declare function branchMergeOf(scope: string[], options: BranchMergeFlags & {
+    [K in (typeof OTHER_FLAGS)[number]]?: unknown;
+}): {
+    solutionId: string;
+    mode: "contributes" | "wins";
+} | null;
+/** What a merge says it did, line by line; and whether it did it. */
+export declare function describeMerge(outcome: MergeOutcome): {
+    lines: string[];
+    ok: boolean;
+};
+export declare function branchMergeCommand(merge: {
+    solutionId: string;
+    mode: "contributes" | "wins";
+}): Promise<void>;
+export {};
+//# sourceMappingURL=branch-merge.d.ts.map

package/dist/commands/branch-merge.js

@@ -0,0 +1,129 @@
+import { webApiUrl } from "../cloud.js";
+import { getProjectCredentials } from "../utils/project-settings.js";
+import { checkedOut } from "./solution/share.js";
+/** The flags a branch merge can't be combined with (BRANCH-8.3). */
+const OTHER_FLAGS = [
+    "cloudContributes",
+    "repoContributes",
+    "cloudWins",
+    "repoWins",
+    "share",
+    // The merge runs on the linked project's credential; a project named here
+    // would be quietly ignored, so it is refused instead.
+    "project",
+];
+/**
+ * The merge a sync's flags ask for, or null when they ask for none. Throws,
+ * saying so, when they combine a merge with anything else (BRANCH-8.3).
+ */
+export function branchMergeOf(scope, options) {
+    const contributes = options.branchContributes;
+    const wins = options.branchWins;
+    if (contributes === undefined && wins === undefined)
+        return null;
+    const combined = (contributes !== undefined && wins !== undefined) ||
+        scope.length > 0 ||
+        OTHER_FLAGS.some((flag) => options[flag]);
+    if (combined) {
+        throw new Error("A branch merge can't be combined with other sync flags or a scope: run `dotreq sync --branch-contributes <solution-id>` or `dotreq sync --branch-wins <solution-id>` on its own.");
+    }
+    return contributes !== undefined
+        ? { solutionId: contributes, mode: "contributes" }
+        : { solutionId: wins, mode: "wins" };
+}
+/** What a merge says it did, line by line; and whether it did it. */
+export function describeMerge(outcome) {
+    if (outcome.kind === "no branch") {
+        return {
+            lines: ["That solution has nothing on a branch to merge."],
+            ok: false,
+        };
+    }
+    const title = outcome.plan.solution.title;
+    if (outcome.kind === "merged") {
+        return {
+            lines: [
+                `Merged the "${title}" branch into main.`,
+                ...outcome.landed.map((doc) => `  landed: ${doc}`),
+            ],
+            ok: true,
+        };
+    }
+    if (outcome.kind === "stopped") {
+        return {
+            lines: [
+                `The "${title}" merge stopped at ${outcome.at}: ${outcome.reason}`,
+                ...outcome.landed.map((doc) => `  landed: ${doc}`),
+            ],
+            ok: false,
+        };
+    }
+    const refusal = outcome.plan.refusal;
+    switch (refusal.kind) {
+        case "conflicts":
+            return {
+                lines: [
+                    `Nothing merged: these documents on the "${title}" branch conflict with main.`,
+                    ...refusal.documents.map((doc) => `  conflict: ${doc}`),
+                    "Resolve them on the branch and merge again, or let the branch win with `dotreq sync --branch-wins <solution-id>`.",
+                ],
+                ok: false,
+            };
+        case "key":
+            return {
+                lines: [
+                    `Nothing merged: ${refusal.document} uses the requirement key ${refusal.key}, which "${refusal.holder}" on main has.`,
+                ],
+                ok: false,
+            };
+        case "limit":
+            return { lines: [`Nothing merged: ${refusal.message}`], ok: false };
+        case "swap":
+            return {
+                lines: [
+                    `Nothing merged: ${refusal.documents.join(" and ")} take each other's requirement keys, which can't land one at a time. Give one of them new keys on the branch.`,
+                ],
+                ok: false,
+            };
+        case "nothing":
+            return {
+                lines: [
+                    `Nothing to merge: every document on the "${title}" branch is already on main.`,
+                ],
+                ok: true,
+            };
+    }
+}
+export async function branchMergeCommand(merge) {
+    // SOLSHARE-5.0: a repository a solution's share command checked out holds
+    // no credential that merges; say so rather than asking for a link.
+    let credentials;
+    try {
+        credentials = getProjectCredentials();
+    }
+    catch (error) {
+        if (checkedOut().length > 0) {
+            throw new Error("Nothing merged: the share command you checked out with can't merge a solution's branch. Whoever runs the solution merges it, from the app.");
+        }
+        throw error;
+    }
+    const { projectId, projectSecret } = credentials;
+    const apiBaseUrl = webApiUrl();
+    const response = await fetch(`${apiBaseUrl}/api/branches/merge`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ ...merge, projectId, projectSecret }),
+    });
+    const body = (await response.json().catch(() => null));
+    if (!body || !("kind" in body)) {
+        throw new Error(body?.error ??
+            `The merge failed (${response.status}).`);
+    }
+    const { lines, ok } = describeMerge(body);
+    for (const line of lines)
+        console.log(line);
+    // BRANCH-8.4: a merge that finds conflicts exits non-zero.
+    if (!ok)
+        process.exitCode = 1;
+}
+//# sourceMappingURL=branch-merge.js.map

package/dist/commands/diff.js

@@ -5,16 +5,17 @@
  * the detail one level. Exits 0 regardless of verdicts unless `--exit-code` is
  * passed, which makes any non-in-sync document exit 1 (the CI drift gate).
  */
-import { acquireCloudSnapshot, acquireLocalSnapshot, compareSnapshots, filterByScope, formatUnitDetail, formatVerdictLine, resolutionHint, } from "../sync/index.js";
+import { acquireCloudSnapshot, acquireLocalSnapshot, compareSnapshots, filterByScope, foreignDocumentNotes, formatUnitDetail, formatVerdictLine, resolutionHint, } from "../sync/index.js";
 import { brand } from "../utils/brand.js";
 import { resolveCloudAuth } from "./sync-common.js";
 export async function diffCommand(scope, options) {
     const workspaceRoot = process.cwd();
     const auth = resolveCloudAuth(options);
-    const [local, cloud] = await Promise.all([
-        acquireLocalSnapshot(workspaceRoot),
-        acquireCloudSnapshot(auth),
-    ]);
+    // SOLACCESS-2.2: as the sync carries them.
+    const cloud = await acquireCloudSnapshot(auth);
+    const local = await acquireLocalSnapshot(workspaceRoot, undefined, {
+        solutions: cloud.solutions === true,
+    });
     const comparison = compareSnapshots(local, cloud);
     const { documents, unmatched } = filterByScope(comparison, scope, workspaceRoot);
     for (const token of unmatched) {
@@ -38,12 +39,21 @@ export async function diffCommand(scope, options) {
         console.log("No documents to compare.");
         return;
     }
+    // SYNC-FAIL-5: a file whose id names another project's document is only
+    // in the repo, and a sync will refuse it; say so here as the sync will.
+    const foreign = await foreignDocumentNotes(auth, documents.flatMap((d) => d.verdict === "only_in_repo" && d.documentId ? [d.documentId] : []));
     console.log(`\n=== Repo vs ${brand} cloud ===\n`);
     for (const doc of documents) {
         console.log(formatVerdictLine(doc));
         if (doc.verdict === "invalid_file" && doc.error) {
             console.log(`      ${doc.error}`);
         }
+        const foreignNote = doc.verdict === "only_in_repo" && doc.documentId
+            ? foreign.get(doc.documentId)
+            : undefined;
+        if (foreignNote) {
+            console.log(`      ${foreignNote}`);
+        }
         if (verbose && doc.details && doc.details.length > 0) {
             for (const detail of doc.details) {
                 console.log(formatUnitDetail(detail));

package/dist/commands/mockup/index.d.ts

@@ -0,0 +1,11 @@
+import type { Command } from "commander";
+export declare function guideCommand(): Promise<void>;
+export declare function createCommand(options: {
+    title: string;
+    file: string;
+}): Promise<void>;
+export declare function previewCommand(mockupId: string, options: {
+    out?: string;
+}): Promise<void>;
+export declare function registerMockup(program: Command): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/mockup/index.js

@@ -0,0 +1,82 @@
+import { readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { webApiUrl } from "../../cloud.js";
+import { api } from "../../convex.js";
+import { getProjectCredentials } from "../../utils/project-settings.js";
+import { solutionClient } from "../solution/client.js";
+/**
+ * Hidden from help until solutions launch: today's users see the CLI they
+ * have now, and the server refuses these commands for a team without the
+ * solutions switch (SOLACCESS-2).
+ */
+const HIDDEN_UNTIL_LAUNCH = { hidden: true };
+/**
+ * Mockups from the shell (SIGHT-5): the guide, a mockup made from a file,
+ * and a mockup rendered to a file an agent can open in its browser. The
+ * guide and the render come through the app, which owns the dialect's
+ * text and its renderer; the create goes to the backend.
+ */
+async function throughApp(path, extra) {
+    const { projectId, projectSecret } = getProjectCredentials();
+    const base = webApiUrl();
+    const response = await fetch(`${base}${path}`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ projectId, projectSecret, ...extra }),
+    });
+    if (!response.ok) {
+        const body = (await response.json().catch(() => ({})));
+        throw new Error(body.error || response.statusText);
+    }
+    return response;
+}
+export async function guideCommand() {
+    const response = await throughApp("/api/mockups/guide", {});
+    const { guide } = (await response.json());
+    process.stdout.write(`${guide}\n`);
+}
+export async function createCommand(options) {
+    const markup = readFileSync(resolve(options.file), "utf8");
+    const client = solutionClient();
+    const { mockupId } = await client.mutation(api.mockups.mutations.create, { project: client.project, title: options.title, markup });
+    console.log(`Created mockup ${mockupId}. Submit it as mockup:${mockupId}; render it with: dotreq mockup preview ${mockupId} --out mockup.html`);
+}
+export async function previewCommand(mockupId, options) {
+    const response = await throughApp("/api/mockups/frame", { mockupId });
+    const html = await response.text();
+    const out = resolve(options.out ?? `mockup-${mockupId}.html`);
+    writeFileSync(out, html);
+    console.log(`Wrote ${out}. Look at it: agent-browser open file://${out} && agent-browser screenshot mockup.png`);
+}
+export function registerMockup(program) {
+    const mockup = program
+        .command("mockup", HIDDEN_UNTIL_LAUNCH)
+        .description("Make and look at wireframe mockups");
+    mockup
+        .command("guide")
+        .description("Print the mockup authoring guide: the markup dialect, the components, a complete example")
+        .action(wrap(guideCommand));
+    mockup
+        .command("create")
+        .description("Create a mockup in the project from a markup file")
+        .requiredOption("--title <title>", "The mockup's title")
+        .requiredOption("--file <path>", "The markup file")
+        .action(wrap(createCommand));
+    mockup
+        .command("preview <mockup-id>")
+        .description("Render a mockup to a self-contained HTML file, to open in a browser")
+        .option("--out <path>", "Where to write it (default: mockup-<id>.html)")
+        .action(wrap(previewCommand));
+}
+function wrap(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        catch (error) {
+            console.error(`\nError: ${error instanceof Error ? error.message : String(error)}\n`);
+            process.exitCode = 1;
+        }
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/scores/index.d.ts

@@ -0,0 +1,50 @@
+import type { Command } from "commander";
+import type { Scores } from "../solution/things.js";
+/**
+ * Scores from the shell (VERB-7, SCORES-1): a solution's price on CREATED's
+ * seven axes, made with `create` and revised with `update`, each axis a
+ * whole number from 1 to 5 with a reason. Like a board or a mockup, scores
+ * are a thing: `create` prints the `scores:<id>` a writer submits with
+ * `dotreq solution author`, whose comment says what changed and why.
+ * Nothing reaches the backend unless every axis is whole, and the backend
+ * refuses the same again.
+ */
+/**
+ * The seven axes as `dotreq scores` takes them (VERB-7): the key the backend stores,
+ * the name a person reads, and the option, which is also how a line of the
+ * reasons file names the axis. The backend's own list is
+ * packages/convex/solutions/scores.ts; the CLI can't import it, so a test
+ * keeps the two equal.
+ */
+export declare const AXES: ReadonlyArray<{
+    key: keyof Scores;
+    label: string;
+    option: string;
+}>;
+export type ScoresOptions = {
+    costOfDelay?: string;
+    relevance?: string;
+    entities?: string;
+    api?: string;
+    testing?: string;
+    experience?: string;
+    doubt?: string;
+    /** A file with one line per axis: `<axis>: <reason>`. */
+    reasons?: string;
+};
+/**
+ * Each axis's reason from the reasons file (VERB-7.0): one line an axis,
+ * `<axis>: <reason>`, the axis spelled as its option is, in any case; a
+ * leading "- " and blank lines are passed over. Refuses a line in another
+ * form, an axis that isn't one of the seven or is named twice (VERB-7.3),
+ * and an axis with no reason (VERB-7.2).
+ */
+export declare function reasonsFrom(text: string, file: string): Record<keyof Scores, string>;
+/** `dotreq scores create`: new scores, and the reference to record them by (VERB-7.0). */
+export declare function createCommand(options: ScoresOptions): Promise<void>;
+/** `dotreq scores update <id>`: all seven axes again, for a revision (VERB-7.1). */
+export declare function updateCommand(scoresId: string, options: ScoresOptions): Promise<void>;
+/** The axes, the reasons file and an example, on `scores --help` (VERB-7.4). */
+export declare const SCORES_HELP = "\nScores are seven axes, each a whole number from 1 to 5 with one line of reasoning:\n  suitability, whether to do this now:\n    --cost-of-delay, --relevance\n  appetite, what it takes to build and how likely the other six are wrong:\n    --entities, --api, --testing, --experience, --doubt\n\nThe reasons file has one line per axis, the axis named as its option is,\nwithout the dashes:\n  cost-of-delay: <why this score>\n  relevance: <why>\n  entities: <why>\n  api: <why>\n  testing: <why>\n  experience: <why>\n  doubt: <why>\n\ncreate prints the scores' reference; record them with it, as any work is\nrecorded. To revise them, update them with all seven axes again and record\nthem again.\n\nExamples:\n  dotreq scores create --cost-of-delay 4 --relevance 3 --entities 2 --api 2 \\\n    --testing 2 --experience 3 --doubt 2 --reasons reasons.txt\n  dotreq solution author scores:<id> --comment \"Scored against the pitch's draft and the discovery board.\"\n  dotreq scores update <id> --cost-of-delay 4 --relevance 3 --entities 3 --api 2 \\\n    --testing 2 --experience 3 --doubt 3 --reasons reasons.txt\n";
+export declare function registerScores(program: Command): void;
+//# sourceMappingURL=index.d.ts.map