toolroll 0.9.89 → 0.9.91

package/dist/contracts/cli.d.ts

@@ -235,6 +235,16 @@ export declare const COMMAND_OUTPUTS: {
             error: z.ZodNullable<z.ZodString>;
             retry: z.ZodString;
         }, z.core.$loose>>>;
+        laptop: z.ZodOptional<z.ZodObject<{
+            running: z.ZodBoolean;
+            url: z.ZodNullable<z.ZodString>;
+            pid: z.ZodNullable<z.ZodNumber>;
+            background: z.ZodEnum<{
+                off: "off";
+                on: "on";
+                "other-service": "other-service";
+            }>;
+        }, z.core.$loose>>;
     }, z.core.$loose>, z.ZodObject<{
         envelopeVersion: z.ZodLiteral<1>;
         ok: z.ZodLiteral<false>;
@@ -838,6 +848,68 @@ export declare const COMMAND_OUTPUTS: {
         reason: z.ZodString;
         message: z.ZodOptional<z.ZodString>;
     }, z.core.$loose>], "ok">;
+    readonly welcome: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"welcome">;
+        agent: z.ZodObject<{
+            done: z.ZodBoolean;
+            checking: z.ZodBoolean;
+            agents: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                state: z.ZodString;
+                command: z.ZodNullable<z.ZodString>;
+                inUse: z.ZodBoolean;
+                canUse: z.ZodBoolean;
+            }, z.core.$loose>>;
+            inUse: z.ZodNullable<z.ZodString>;
+            buildsWith: z.ZodNullable<z.ZodString>;
+        }, z.core.$loose>;
+        project: z.ZodObject<{
+            done: z.ZodBoolean;
+            projects: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                path: z.ZodString;
+            }, z.core.$loose>>;
+            sample: z.ZodNullable<z.ZodString>;
+            notTakingWork: z.ZodBoolean;
+        }, z.core.$loose>;
+        task: z.ZodObject<{
+            done: z.ZodBoolean;
+            open: z.ZodBoolean;
+            starters: z.ZodArray<z.ZodObject<{
+                label: z.ZodString;
+                draft: z.ZodString;
+                href: z.ZodString;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+        next: z.ZodNullable<z.ZodEnum<{
+            agent: "agent";
+            project: "project";
+            task: "task";
+        }>>;
+        left: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"welcome">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
+    readonly "password set": z.ZodDiscriminatedUnion<[z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<true>;
+        command: z.ZodLiteral<"password set">;
+        account: z.ZodString;
+        generation: z.ZodNumber;
+    }, z.core.$loose>, z.ZodObject<{
+        envelopeVersion: z.ZodLiteral<1>;
+        ok: z.ZodLiteral<false>;
+        command: z.ZodLiteral<"password set">;
+        reason: z.ZodString;
+        message: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>], "ok">;
 };
 /** The schema for `command`'s answer: its own when it names its fields, else the envelope under its own name. */
 export declare function commandOutputSchema(command: string): z.ZodType;

package/dist/contracts/cli.js

@@ -90,6 +90,9 @@ const statusOutput = answers("status", {
     integrations: z.looseObject({ broken: rows({ key: str, name: str, fix: nullable(str) }) }).optional(),
     updateWaiting: z.looseObject({}).optional(),
     unsentReplies: rows({ since: str, error: nullable(str), retry: str }).optional(),
+    // This computer's console (easy-start D): proven live or not, its address and console process, and whether a
+    // background service runs it — ours, another on this database or the desktop app's, or none. Not for a person limited to some projects.
+    laptop: z.looseObject({ running: z.boolean(), url: nullable(str), pid: nullable(int), background: z.enum(["on", "off", "other-service"]) }).optional(),
 });
 /** One integration (`integrations.ts` Integration): never a secret. */
 const integrationRow = z.looseObject({
@@ -203,6 +206,16 @@ export const COMMAND_OUTPUTS = {
     reap: answers("reap", { count: int, released: list }),
     audit: auditOutput,
     "skills list": answers("skills list", { guides: rows({ name: str, title: str, oneLiner: str }) }),
+    // The welcome's three steps (first-run.ts welcomeModel), the same model the console's /welcome shows.
+    welcome: answers("welcome", {
+        agent: z.looseObject({ done: z.boolean(), checking: z.boolean(), agents: rows({ id: str, name: str, state: str, command: nullable(str), inUse: z.boolean(), canUse: z.boolean() }), inUse: nullable(str), buildsWith: nullable(str) }),
+        project: z.looseObject({ done: z.boolean(), projects: rows({ name: str, path: str }), sample: nullable(str), notTakingWork: z.boolean() }),
+        task: z.looseObject({ done: z.boolean(), open: z.boolean(), starters: rows({ label: str, draft: str, href: str }) }),
+        next: nullable(z.enum(["agent", "project", "task"])),
+        left: int,
+    }),
+    // The first password set: whose, and the account generation every older session was bound to before it.
+    "password set": answers("password set", { account: str, generation: int }),
 };
 const declared = new Map(Object.entries(COMMAND_OUTPUTS));
 /** The schema for `command`'s answer: its own when it names its fields, else the envelope under its own name. */

package/dist/contracts/console-api.d.ts

@@ -61,7 +61,9 @@ export declare const CONSOLE_FORMS: {
     readonly signup: FormContract<"code" | "name" | "password">;
     readonly login: FormContract<"name" | "return" | "token">;
     readonly join: FormContract<"name" | "password">;
-    readonly mutationGuard: FormContract<"confirm" | "csrf" | "digest" | "nonce" | "token">;
+    readonly rekey: FormContract<"return" | "token">;
+    readonly passwordSet: FormContract<"again" | "csrf" | "next" | "password" | "return" | "toolroll-key">;
+    readonly mutationGuard: FormContract<"confirm" | "csrf" | "digest" | "nonce" | "token" | "toolroll-key">;
     readonly ledgerTarget: FormContract<"repo">;
     readonly projectCeiling: FormContract<"repo">;
     readonly demo: FormContract<"message" | "note">;
@@ -72,6 +74,7 @@ export declare const CONSOLE_FORMS: {
     readonly code: FormContract<"acceptance" | "answers" | "base" | "candidate" | "decision" | "goal" | "model" | "password" | "prompt" | "repo" | "requestId" | "title" | "visual" | `question:${string}`>;
     readonly sweep: FormContract<"confirm" | "snapshot">;
     readonly passwordless: FormContract<"action" | "password">;
+    readonly localModeOff: FormContract<"password">;
     readonly releaseApproval: FormContract<"action" | "password" | "repo">;
     readonly term: FormContract<"password" | "program" | "repo">;
     readonly skillsRevise: FormContract<"feedback" | "nonce" | "repo" | "run">;
@@ -156,12 +159,16 @@ export declare const CONSOLE_FORMS: {
     readonly leadAbout: FormContract<"about">;
     readonly leadPromiseCancel: FormContract<"promise">;
     readonly leadCheck: FormContract<"return">;
+    readonly leadOn: FormContract<"agent" | "return">;
+    readonly welcomeSample: FormContract<never>;
     readonly chatConfig: FormContract<"daily-turns" | "forget-key" | "key" | "model" | "off" | "provider" | "return" | "token" | "weekly-usd">;
     readonly leadMint: FormContract<"ceiling-usd" | "follow" | "return" | "token">;
     readonly leadFollow: FormContract<"enabled" | "return">;
     readonly leadEnd: FormContract<"return">;
     readonly leadStop: FormContract<"return" | "turn">;
     readonly leadQueuedRemove: FormContract<"return">;
+    readonly agentSeen: FormContract<"run">;
+    readonly agentWatch: FormContract<"op" | "run" | "view">;
     readonly leadProposal: FormContract<"confirm" | "nonce" | "return" | "token">;
     readonly coordinatorProposal: FormContract<"confirm" | "return">;
     readonly chat: FormContract<"message" | "mode" | "project" | "request" | "request-session" | "result" | "task" | "token">;
@@ -200,7 +207,7 @@ export declare const CONSOLE_FORMS: {
 };
 export type ConsoleFormName = keyof typeof CONSOLE_FORMS;
 /** The console POSTs whose handlers read no field (sign-out not even the shared guard): their contract is the empty form. */
-export declare const BODILESS_POSTS: readonly ["POST /settings/models/<unknown action>", "POST /settings/lead/on", "POST /r/<run>/draft-repair", "POST /ledger/checkpoint", "POST /settings/backups/now", "POST /mode/revoke", "POST /settings/telegram/retry", "POST /providers/<provider>/resume", "POST /logout", "POST /t/<task>/unhold", "POST /t/<task>/stop-carrying", "POST /t/<task>/plan", "POST /t/<task>/retry-review", "POST /settings/updates/check", "POST /settings/storage/check", "POST /projects/github", "POST /code/<session>/ship/preview"];
+export declare const BODILESS_POSTS: readonly ["POST /settings/models/<unknown action>", "POST /r/<run>/draft-repair", "POST /ledger/checkpoint", "POST /settings/backups/now", "POST /mode/revoke", "POST /settings/telegram/retry", "POST /providers/<provider>/resume", "POST /logout", "POST /t/<task>/unhold", "POST /t/<task>/stop-carrying", "POST /t/<task>/plan", "POST /t/<task>/retry-review", "POST /settings/updates/check", "POST /settings/storage/check", "POST /projects/github", "POST /code/<session>/ship/preview"];
 /** The field names a console form's handler may read. */
 export type FormFieldOf<N extends ConsoleFormName> = (typeof CONSOLE_FORMS)[N] extends FormContract<infer K> ? K : never;
 /** `GET /ledger?format=json`: the chain's state, a page of entries (newest first) and the cursor for the next. */

package/dist/contracts/console-api.js

@@ -69,8 +69,10 @@ export const CONSOLE_FORMS = {
     signup: formContract("POST /signup", ["code", "name", "password"]),
     login: formContract("POST /login", ["name", "token", "return"]),
     join: formContract("POST /join/<invite>", ["name", "password"]),
+    rekey: formContract("POST /login/rekey", ["token", "return"]),
+    passwordSet: formContract("POST /password/set", ["csrf", "password", "again", "next", "return", "toolroll-key"]),
     // Shared by every signed-in POST.
-    mutationGuard: formContract("POST (every signed-in form)", ["csrf", "token", "digest", "nonce", "confirm"]),
+    mutationGuard: formContract("POST (every signed-in form)", ["csrf", "token", "digest", "nonce", "confirm", "toolroll-key"]),
     ledgerTarget: formContract("POST (the action ledger's project)", ["repo"]),
     projectCeiling: formContract("POST (project ceiling)", ["repo"]),
     demo: formContract("POST /chat/demo/ask, /chat/demo/<id>/approve|change|revise|complete", ["message", "note"]),
@@ -81,6 +83,7 @@ export const CONSOLE_FORMS = {
     code: formContract("POST /code, /code/start, /code/<session>/<act>, /code/<anything else>", ["repo", "password", "title", "model", "prompt", "requestId", "base", "candidate", "goal", "acceptance", "visual", "decision", "answers"], { prefixes: ["question:"] }),
     sweep: formContract("POST /sweeps/<sweep>/cancel-rest", ["confirm", "snapshot"]),
     passwordless: formContract("POST /settings/passwordless", ["action", "password"]),
+    localModeOff: formContract("POST /settings/local-mode/off", ["password"]),
     releaseApproval: formContract("POST /settings/release-approval", ["repo", "action", "password"]),
     term: formContract("POST /term/start, /term/<terminal>/close, /term/<terminal>/remove", ["repo", "program", "password"]),
     skillsRevise: formContract("POST /settings/skills/revise", ["run", "repo", "feedback", "nonce"]),
@@ -169,12 +172,17 @@ export const CONSOLE_FORMS = {
     leadAbout: formContract("POST /settings/lead/about", ["about"]),
     leadPromiseCancel: formContract("POST /settings/lead/promise/cancel", ["promise"]),
     leadCheck: formContract("POST /lead/check", ["return"]),
+    leadOn: formContract("POST /settings/lead/on", ["agent", "return"]),
+    welcomeSample: formContract("POST /welcome/sample", []),
     chatConfig: formContract("POST /chat/config", ["return", "token", "off", "forget-key", "provider", "model", "weekly-usd", "daily-turns", "key"]),
     leadMint: formContract("POST /chat/mate/mint", ["return", "ceiling-usd", "token", "follow"]),
     leadFollow: formContract("POST /chat/mate/follow", ["enabled", "return"]),
     leadEnd: formContract("POST /chat/mate/end", ["return"]),
     leadStop: formContract("POST /chat/mate/stop", ["return", "turn"]),
     leadQueuedRemove: formContract("POST /chat/queued/<message>/remove", ["return"]),
+    // Easy-start C1 (N1): what a page load used to write, now a keyed POST from the shell.
+    agentSeen: formContract("POST /agents/seen", ["run"]),
+    agentWatch: formContract("POST /agents/watch", ["run", "view", "op"]),
     leadProposal: formContract("POST /chat/proposal/<id>/confirm|dismiss", ["return", "nonce", "confirm", "token"]),
     coordinatorProposal: formContract("POST /proposals/<id>/confirm|dismiss", ["return", "confirm"]),
     chat: formContract("POST /chat", ["task", "project", "result", "mode", "request", "request-session", "message", "token"]),
@@ -218,7 +226,6 @@ export const CONSOLE_FORMS = {
 /** The console POSTs whose handlers read no field (sign-out not even the shared guard): their contract is the empty form. */
 export const BODILESS_POSTS = [
     "POST /settings/models/<unknown action>",
-    "POST /settings/lead/on",
     "POST /r/<run>/draft-repair",
     "POST /ledger/checkpoint",
     "POST /settings/backups/now",

package/dist/desktop-host.js

@@ -9,6 +9,7 @@ import { openStore, openStoreNoMigrate, databasePath, readSchemaVersion, SCHEMA_
 import { createRequire } from "node:module";
 import { authenticateApprover, hashPassword } from "./scope.js";
 import { runOperate, writeLoginFileDurably } from "./operate.js";
+import { ensureSecretsDir, migrateLegacyLogin, savedLoginFile } from "./login-secrets.js";
 import { daemonStatus, installLaunchdService, planDesktopService, stopLaunchdService } from "./daemon.js";
 import { run as execRun } from "./exec.js";
 import { containmentStatus, effectiveContainment, parseContainmentPolicy, probeContainmentCapability } from "./containment.js";
@@ -172,7 +173,7 @@ export function pairDesktopLogin(store, file, login) {
         writeLoginFileDurably(file, login.name, login.password);
     }
     else if (!(first && remembered.name === login.name && remembered.password === login.password) && !authenticateApprover(store, remembered.name, remembered.password).ok) {
-        throw new Error("The existing up-login.txt is stale. Restore its valid login before starting the desktop service.");
+        throw new Error("The saved login (up-login.txt) is stale. Restore its valid login before starting the desktop service.");
     }
     if (first)
         store.bootstrapApproverIfNone(login.name, hashPassword(login.password), new Date());
@@ -371,7 +372,8 @@ export async function desktopMain(argv, supervise = execRun) {
     }
     // Inspection and launch must never migrate another running controller.
     const store = openConfiguredDesktopStore(stateDir);
-    const legacyFile = join(dirname(config.databaseFile), "up-login.txt");
+    // The saved login: in the reserved folder every agent fence denies (login-secrets.ts), else where older versions kept it.
+    const legacyFile = savedLoginFile(dirname(config.databaseFile));
     if (argv[0] !== "serve-controller") {
         try {
             if (argv[0] === "inspect") {
@@ -387,7 +389,10 @@ export async function desktopMain(argv, supervise = execRun) {
             }
             else if (argv[0] === "pair") {
                 const login = await readInput();
-                pairDesktopLogin(store, legacyFile, login);
+                // A login saved here goes into the reserved folder, made and proven first; an older one moves in.
+                migrateLegacyLogin(dirname(config.databaseFile));
+                ensureSecretsDir(dirname(config.databaseFile));
+                pairDesktopLogin(store, savedLoginFile(dirname(config.databaseFile)), login);
                 console.log(JSON.stringify({ ok: true }));
             }
             else if (argv[0] === "add-repo" || argv[0] === "add-repos") {

package/dist/desktop-update.js

@@ -3,6 +3,7 @@ import { createHash, randomUUID } from "node:crypto";
 import { closeSync, chmodSync, copyFileSync, cpSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { savedLoginFile } from "./login-secrets.js";
 import { createRequire } from "node:module";
 import { bundleHash, readDesktopBundle, verifyDesktopUpdateBundles } from "./desktop-bundle.js";
 import { readDesktopConfig, desktopServiceCommand, desktopServiceDefinition, verifyDesktopLiveness } from "./desktop-host.js";
@@ -535,7 +536,7 @@ async function verifiedBackup(j) {
     const backupHash = await verifiedDatabaseBackup(j.databaseFile, backupPath, j.id, async () => {
         await verifiedCodingBackup(j);
     }, () => {
-        for (const [source, name] of [[join(j.stateDir, "desktop.json"), "desktop.json"], [join(dirname(j.databaseFile), "repos.json"), "repos.json"], [join(dirname(j.databaseFile), "up-login.txt"), "up-login.txt"]]) {
+        for (const [source, name] of [[join(j.stateDir, "desktop.json"), "desktop.json"], [join(dirname(j.databaseFile), "repos.json"), "repos.json"], [savedLoginFile(dirname(j.databaseFile)), "up-login.txt"]]) {
             if (source && name && existsSync(source)) {
                 if (!lstatSync(source).isFile() || lstatSync(source).isSymbolicLink())
                     throw Error("A saved configuration file is linked or not a regular file. Nothing was replaced.");

package/dist/dispatch.d.ts

@@ -118,3 +118,6 @@ export declare function diagnosisIsDispatchable(diagnosis: DispatchDiagnosis | n
 /** Attach the same lifecycle answer to the bounded fleet snapshot used by
  * both direct chat and the long-running lead. */
 export declare function withDispatchDiagnoses(store: Store, snapshot: ChatSnapshot, now: Date): ChatSnapshot;
+/** When a backed-off task tries again, as a person reads it: "in under a minute", "in 3 minutes", or a later day's
+ * time in UTC (the console's own clock words, when-html.ts shortWhen). */
+export declare function retryWhenWords(until: string, now: Date): string;

package/dist/dispatch.js

@@ -17,6 +17,7 @@ import { replacedWords } from "./task-status.js";
 import { failedAttemptSentence, latestFinishedAttempt } from "./needs-you.js";
 import { buildReviewOf } from "./review-switch.js";
 import { BUILT_IN, refArchived, parseCapabilityKey } from "./store.js";
+import { shortWhen } from "./when-html.js";
 export const DEFAULT_MAX_OPEN_DECISIONS = 5;
 /**
  * Task state, active holds, and unfinished dependencies in the exact order
@@ -260,10 +261,11 @@ export function diagnoseTaskDispatch(store, taskId, now, readableRepos = null) {
         if (local.ownerKind === "backoff") {
             // Run 2085: an attempt that stopped before its handoff says so plainly.
             const last = store.runsFor(ref.id).find(one => one.role === "builder" && one.finishedAt !== null);
-            const when = local.until === null ? "" : ` The next attempt is eligible at ${local.until}.`;
+            // Said once, with a time a person reads (nextAt keeps the exact stamp for machines).
+            const when = local.until === null ? "" : ` It tries again ${retryWhenWords(local.until, now)}.`;
             if (last?.reason === "no-handoff")
                 return answer("retry-scheduled", "retrying", "Retry scheduled", `The agent stopped before handing off; its work was kept and it is being resumed.${when}`, { nextAt: local.until });
-            return answer("retry-scheduled", "retrying", "Retry scheduled", local.until === null ? "The failed attempt is backing off before retrying." : `The next attempt is eligible at ${local.until}.`, { nextAt: local.until });
+            return answer("retry-scheduled", "retrying", "Retry scheduled", local.until === null ? "The failed attempt is backing off before retrying." : `It tries again ${retryWhenWords(local.until, now)}.`, { nextAt: local.until });
         }
         if (local.ownerKind === "decision")
             return answer("waiting-decision", "waiting", "Waiting on your answer", "An agent parked a question; answering it resumes the task.", { action: "answer-decision" });
@@ -358,3 +360,21 @@ export function withDispatchDiagnoses(store, snapshot, now) {
         tasks: snapshot.tasks.map(one => ({ ...one, dispatch: diagnoseTaskDispatch(store, one.id, now) })),
     };
 }
+/** When a backed-off task tries again, as a person reads it: "in under a minute", "in 3 minutes", or a later day's
+ * time in UTC (the console's own clock words, when-html.ts shortWhen). */
+export function retryWhenWords(until, now) {
+    const ms = Date.parse(until) - now.getTime();
+    if (Number.isNaN(ms))
+        return "soon";
+    if (ms <= 60_000)
+        return "in under a minute";
+    const minutes = Math.ceil(ms / 60_000);
+    if (minutes < 60)
+        return `in ${minutes} minutes`;
+    const at = shortWhen(until, now, "UTC", true);
+    if (/^\d/.test(at))
+        return `at ${at} UTC`;
+    if (at.startsWith("Tomorrow "))
+        return `tomorrow at ${at.slice("Tomorrow ".length)} UTC`;
+    return `on ${at} UTC`;
+}

package/dist/easy-start-args.d.ts

@@ -0,0 +1,13 @@
+/** Which invocations are an easy start (easy-start.ts), kept apart so the CLI's entry decides without loading it. */
+export type EasyStartArgs = {
+    web: boolean;
+    projectRoot: string | null;
+};
+/** The flags bare `toolroll` takes at a terminal (--web, --project-root <dir>), or null: not an easy start. */
+export declare function easyStartArgs(argv: readonly string[]): EasyStartArgs | null;
+/** Whether this invocation is an easy start: only those flags, a person at a terminal, no coding agent. */
+export declare function easyStartApplies(argv: readonly string[], facts: {
+    stdin: boolean;
+    stdout: boolean;
+    agent: boolean;
+}): boolean;

package/dist/easy-start-args.js

@@ -0,0 +1,24 @@
+/** Which invocations are an easy start (easy-start.ts), kept apart so the CLI's entry decides without loading it. */
+/** The flags bare `toolroll` takes at a terminal (--web, --project-root <dir>), or null: not an easy start. */
+export function easyStartArgs(argv) {
+    let web = false, projectRoot = null;
+    for (let index = 0; index < argv.length; index += 1) {
+        const one = argv[index];
+        if (one === "--web" && !web)
+            web = true;
+        else if (one === "--project-root" && projectRoot === null) {
+            const value = argv[index + 1];
+            if (value === undefined || value === "" || value.startsWith("-"))
+                return null;
+            projectRoot = value;
+            index += 1;
+        }
+        else
+            return null;
+    }
+    return { web, projectRoot };
+}
+/** Whether this invocation is an easy start: only those flags, a person at a terminal, no coding agent. */
+export function easyStartApplies(argv, facts) {
+    return facts.stdin && facts.stdout && !facts.agent && easyStartArgs(argv) !== null;
+}

package/dist/easy-start.d.ts

@@ -0,0 +1,77 @@
+import { type AttachProof } from "./console-instance.js";
+import type { TuiExit, TuiSession } from "./tui-contract.js";
+export { easyStartApplies, easyStartArgs, type EasyStartArgs } from "./easy-start-args.js";
+import type { EasyStartArgs } from "./easy-start-args.js";
+/** The `up` this process started and owns. */
+export type OwnedUp = {
+    pid: number;
+    exited: Promise<number | null>;
+    running(): boolean;
+    stop(): void;
+    tail(): readonly string[];
+};
+export type EasyStartSeams = {
+    databaseFile: string;
+    cwd: string;
+    write: (line: string) => void;
+    /** Prove this database's console live (read only). */
+    prove: () => Promise<AttachProof>;
+    /** Local mode as saved now: on, off, or no database yet (a new install). */
+    localMode: () => "on" | "off" | "absent";
+    serviceInstalled: () => boolean;
+    /** Start the installed background service through its supervisor and prove its console. */
+    startService: () => Promise<AttachProof>;
+    /** `up` (with these arguments) as an ordinary child of this process. */
+    spawnUp: (args: readonly string[]) => OwnedUp;
+    /** `up` (with these arguments) in this terminal, until it stops: today's foreground start. */
+    runUpForeground: (args: readonly string[]) => Promise<number>;
+    openBrowser: (url: string) => void | Promise<void>;
+    /** A local owner's one-time sign-in address from the live console (the socket `link` verb). */
+    requestLink: () => Promise<{
+        ok: true;
+        url: string;
+    } | {
+        ok: false;
+        message: string;
+    }>;
+    /** The terminal UI, in this process, as the local owner, until the person quits. */
+    openTui: (session: TuiSession) => Promise<TuiExit>;
+    /** `background on`, handing over from the `up` this process owns (when it owns one). */
+    backgroundOn: (foreground: {
+        controllerPid: number;
+        restart: () => Promise<void>;
+    } | null) => Promise<{
+        ok: boolean;
+        message: string;
+    }>;
+    backgroundAsked: () => boolean;
+    recordBackgroundAnswer: (yes: boolean) => void;
+    /** This folder's repository, whether it is added, and adding it (only when attaching to a running console). */
+    findRepo: (cwd: string) => Promise<string | null>;
+    enrolled: (repo: string) => Promise<boolean>;
+    admit: (repo: string) => Promise<number>;
+    sleep?: (ms: number) => Promise<void>;
+    startTimeoutMs?: number;
+};
+/**
+ * Bare `toolroll` ("start") or `toolroll open` ("open") at a person's terminal. Resolves with the exit code once the
+ * screen (or the foreground `up`, or the browser hand-off) is done.
+ */
+export declare function runEasyStart(mode: "start" | "open", args: EasyStartArgs, seams: EasyStartSeams): Promise<number>;
+/** `up` as an ordinary child of this process: its output kept (last lines, for a failed start), never on the screen. */
+export declare function spawnOwnedUp(args: readonly string[], options: {
+    cwd: string;
+    databaseFile: string;
+    entry?: string;
+}): OwnedUp;
+/** The real seams, for this installation's database. */
+export declare function defaultEasyStartSeams(options: {
+    databaseFile: string;
+    write: (line: string) => void;
+    build: string;
+    cwd?: string;
+    operate?: import("./operate.js").OperateOptions;
+    admit: (repo: string) => Promise<number>;
+}): EasyStartSeams;
+/** Local mode as saved, read only: "absent" with no database yet; an older database has none ("off"). */
+export declare function localModeRead(file: string): "on" | "off" | "absent";