toolroll 0.9.89 → 0.9.90

package/dist/model-choices.js

@@ -9,6 +9,7 @@
  */
 import { createHash } from "node:crypto";
 import { isAcpProvider } from "./acp-agents.js";
+import { currentLocalOwner, localModeOn, localOwnerInFlight, localOwnerStandsNow } from "./local-owner.js";
 import { INSTALLATION_SCOPE, resolvePhaseAgent, resolveRouteCandidates } from "./agentconfig.js";
 import { seenModels } from "./model-catalog.js";
 import { passwordlessOn } from "./passwordless.js";
@@ -403,3 +404,82 @@ function extraWrite(store, scope, repo, op, actor, now) {
     ledger(`other-provider ${op.tier} agent for ${op.phase} changed`, `${pairWords(before)} → ${pairWords({ provider: op.provider, model: op.model })}`);
     return 1;
 }
+// ---- a first agent's default routing (easy start) -------------------------------
+/** Codex's exact ids for its "Sized by job" preset: the frontier model plans, reviews and builds large or risky
+ * work, the workhorse builds routine work, the small model builds small work (the ids Codex lists as of 2026-11). */
+export const CODEX_FRONTIER = "gpt-6-astra";
+export const CODEX_WORKHORSE = "gpt-6-sol";
+export const CODEX_SMALL = "gpt-6-luna";
+/** Each agent's default preset: what a new installation runs on once that agent is chosen and nothing is set yet. */
+export const AGENT_PRESETS = Object.freeze({
+    claude: PRESETS[DEFAULT_PRESET],
+    codex: {
+        label: "Sized by job",
+        words: `Small tasks build on ${CODEX_SMALL}, routine tasks on ${CODEX_WORKHORSE}, large or risky tasks on ${CODEX_FRONTIER}. Planning and review always use ${CODEX_FRONTIER}.`,
+        rows: { plan: CODEX_FRONTIER, "plan-strong": CODEX_FRONTIER, "build-light": CODEX_SMALL, build: CODEX_WORKHORSE, "build-strong": CODEX_FRONTIER, repair: null, "repair-strong": null, review: CODEX_FRONTIER, "review-strong": CODEX_FRONTIER },
+    },
+});
+/** An agent's default preset as a change: every slot, exact ids, repairs following each size's builder. */
+export function agentPresetChange(agent) {
+    return ALL_SLOTS.map(slot => {
+        const model = AGENT_PRESETS[agent].rows[slotKey(slot)];
+        return { slot, to: model === null || model === undefined ? null : { provider: agent, model } };
+    });
+}
+/** The chat provider a lead runs on, as the agent whose preset it brings; null for a direct API. */
+export function defaultAgentOf(provider) {
+    return provider === "claude-subscription" ? "claude" : provider === "codex-subscription" ? "codex" : null;
+}
+/**
+ * A new installation's first routing: the chosen agent's default preset, written only while NOTHING is set — no role
+ * row, tier row or other-provider candidate at the installation or any project — so it never overwrites a choice.
+ * Checked and written in one transaction (the caller's, when it has one: the lead's own write rides with it), each row
+ * ledgered, the result checked like any apply; a refusal writes nothing.
+ */
+export function fillDefaultRouting(store, agent, actor, door, now) {
+    const refused = (reason, problem) => ({ filled: false, reason, problem });
+    return store.transact(() => {
+        const local = currentLocalOwner();
+        if (door.kind === "local-owner") {
+            if (local === null || !localOwnerInFlight(local) || local.act !== "choose-default-agent" || local.account !== actor || !localOwnerStandsNow(store, local)) {
+                return refused("authority", "Only this computer's owner, choosing an agent now, starts its models.");
+            }
+        }
+        else if (!localModeOn(store)) {
+            // The first start's own choice (serve.ts leadByDefault): it may run inside whichever request asked this computer's
+            // agents again, so it reads no principal; local mode on, and nothing set (below), is what admits it.
+            return refused("authority", "Only a laptop install's first start chooses its models by itself.");
+        }
+        const anyRow = store.handle.prepare("SELECT 1 FROM phase_config UNION ALL SELECT 1 FROM phase_tier_config UNION ALL SELECT 1 FROM phase_tier_alternate LIMIT 1").get();
+        if (anyRow !== undefined)
+            return refused("already-set", "Models are already chosen here.");
+        store.handle.exec("SAVEPOINT default_routing");
+        try {
+            let rows = 0;
+            for (const { slot, to } of agentPresetChange(agent)) {
+                if (to === null)
+                    continue;
+                if (slot.tier === "routine")
+                    store.setPhaseConfig(INSTALLATION_SCOPE, slot.phase, to.provider, to.model, actor, now);
+                else
+                    store.setPhaseTierConfig(INSTALLATION_SCOPE, slot.phase, slot.tier, to.provider, to.model, actor, now);
+                store.recordAction({ at: now.toISOString(), actor, repo: null, taskId: null, runId: null, action: ACTION_OF(slot), outcome: "changed", source: "policy",
+                    detail: `not set → ${pairWords(to)} (${AGENT_PRESETS[agent].label}, the default for the agent chosen)` });
+                rows++;
+            }
+            const checked = checkScope(store, null);
+            if (checked.kind !== "ok") {
+                store.handle.exec("ROLLBACK TO default_routing");
+                store.handle.exec("RELEASE default_routing");
+                return refused("invalid", checked.problem);
+            }
+            store.handle.exec("RELEASE default_routing");
+            return { filled: true, rows };
+        }
+        catch (error) {
+            store.handle.exec("ROLLBACK TO default_routing");
+            store.handle.exec("RELEASE default_routing");
+            throw error;
+        }
+    });
+}

package/dist/operate.d.ts

@@ -6,8 +6,10 @@ import { type GhRead } from "./nightly-github.js";
 import type { StepIo } from "./flow-steps.js";
 import type { FetchLike } from "./flow-share.js";
 import { type Store } from "./store.js";
+import { type LaptopSeams } from "./laptop-background.js";
 import { type DispatchAdapter } from "./sync.js";
-import { type RolePort, type UpRoleStart } from "./up-processes.js";
+import { type ParentToRole, type RolePort, type UpRoleStart, type UpStartAuthority } from "./up-processes.js";
+import { type DecisionServer } from "./serve.js";
 import { type TelegramTransport } from "./telegram.js";
 import { type ProjectIdentities } from "./project-identity.js";
 import { type FolderLookOptions } from "./folder-look.js";
@@ -91,7 +93,14 @@ export type OperateOptions = {
         terminal?: boolean;
         env?: Record<string, string | undefined>;
         openBrowser?: (url: string) => void;
+        home?: string;
+        fenceAvailable?: () => boolean;
+        laptopPorts?: readonly number[];
     };
+    /** Injected by tests: the background service handoff's supervisor, HOME, processes and console proof (laptop-background.ts). */
+    laptopSeams?: LaptopSeams;
+    /** Injected by tests: `open`, `welcome` and `password set` — the terminal, the easy start's seams, the prompts. */
+    easySeams?: EasyCommandSeams;
     /** Injected by tests: the classifier that sizes filed tasks (none by default under test). */
     filingSizer?: Sizer;
     /** Set only by up-role-child.ts: this process is one role of a `toolroll up` (the console or the worker). */
@@ -223,7 +232,13 @@ type Context = {
         terminal?: boolean;
         env?: Record<string, string | undefined>;
         openBrowser?: (url: string) => void;
+        home?: string;
+        fenceAvailable?: () => boolean;
+        laptopPorts?: readonly number[];
     };
+    /** Injected by tests: the background service handoff's supervisor, HOME, processes and console proof (laptop-background.ts). */
+    laptopSeams?: LaptopSeams;
+    easySeams?: EasyCommandSeams;
     /** This process is one role of a `toolroll up`, started by it (never from the command line). */
     upRole?: UpRoleHost;
     /** In-memory seams a child process can't receive: `up` runs its console and worker in this one process. */
@@ -323,3 +338,33 @@ export declare function writeModelRow(store: Store, proved: {
     generation: number;
     method: string;
 }, scope: string, knownProject: (repo: string) => boolean, slot: Slot | null, to: ModelChange["to"], now: Date, extra?: readonly ExtraWrite[]): ApplyResult;
+/** The sign-in link `up` asks its console for, by this start's authority: none for "none". */
+export declare function upLinkRequest(authority: UpStartAuthority, account: string | null): {
+    kind: "full";
+    account: string;
+} | {
+    kind: "local";
+} | null;
+/**
+ * The console's answer to a link request (plan C4): only the kind its own start was authorised for, whatever the
+ * request says. A local start mints only a local owner's link (mintLocalLink names no account); a full start only the
+ * named account's; "none", or a request of the other kind, mints nothing.
+ */
+export declare function consoleSignInLink(server: Pick<DecisionServer, "mintSignInLink" | "mintLocalLink">, startAuthority: UpStartAuthority, message: Extract<ParentToRole, {
+    type: "sign-in-link";
+}>): string | null;
+/** Tests: a person at a terminal, the easy start's seams, the agents' sign-in check, and the prompts. */
+export type EasyCommandSeams = {
+    terminal?: boolean;
+    seams?: Partial<import("./easy-start.js").EasyStartSeams>;
+    check?: import("./provider-connection.js").ConnectionChecker;
+    ask?: (question: string) => Promise<string>;
+    askHidden?: (question: string) => Promise<string>;
+};
+/**
+ * Easy start: the ports `up --laptop` (no --port) tries, in order. The port this install saved, alone; else, for a NEW
+ * laptop install (made by `up --laptop`, nothing saved yet), `up`'s default and the next nineteen, so a console that
+ * isn't this database's (another Toolroll, the desktop app's) never stops a first start; else (an install made any other
+ * way) `up`'s default alone, as before. `fromSeam` replaces the default range in tests.
+ */
+export declare function upLaptopPortCandidates(store: Store, fromSeam?: readonly number[]): number[];