toolroll 0.9.88 → 0.9.90

package/dist/server/render-tasks.d.ts

@@ -119,6 +119,16 @@ export type ApprovalSheetInput = {
     } | null;
     /** Cockpit B2: this person's password is remembered (when, ISO) and these terms may stand on it. */
     freshSince?: string | null;
+    /** Easy-start C5: a laptop's local owner — eligible (no password field), or why not and where to go. */
+    localOwner?: LocalApprovalView | null;
+};
+export type LocalApprovalView = {
+    eligible: true;
+} | {
+    eligible: false;
+    message: string;
+    href: string;
+    action: string;
 };
 /** The approval sheet: one form that restates every term it signs, the password, and Approve & start. */
 export declare function approvalSheetHtml(input: ApprovalSheetInput): Html;
@@ -548,6 +558,8 @@ export declare function taskBodyParts(data: {
     steerRecent?: number[];
     /** Cockpit B2: when this person's remembered password was given, when it may approve these terms. */
     approvalFresh?: string | null;
+    /** Easy-start C5: the viewer is a laptop's local owner — whether this plan is one it approves without a password. */
+    approvalLocal?: LocalApprovalView | null;
     /** Cockpit B2: how the current approval's person was proved (approval proved ledger), when it was a remembered one. */
     approvalProof?: {
         method: string;

package/dist/server/render-tasks.js

@@ -239,9 +239,11 @@ export function approvalSheetHtml(input) {
             parts.lead,
             parts.rows,
             html `<div class="approval-act" id="${input.surface === "task" ? "approval-confirm" : "chat-approval-confirm"}">`,
-            html `${reauth(html `<label class="approval-password"><span class="visually-hidden">Your password</span><input type="password" name="token" autocomplete="current-password" placeholder="Your password" aria-describedby="${parts.passwordNote}"></label>`)}`,
-            input.freshSince == null ? html `<p class="approval-password-note" id="${parts.passwordNote}">Your password signs this approval.</p>`
-                : html `<p class="approval-password-note" id="${parts.passwordNote}" data-approval-fresh>Your password from ${whenTime(input.freshSince)} is remembered on this computer — leave this blank to approve with it, or type it again.</p>`,
+            input.localOwner != null ? html `` : html `${reauth(html `<label class="approval-password"><span class="visually-hidden">Your password</span><input type="password" name="token" autocomplete="current-password" placeholder="Your password" aria-describedby="${parts.passwordNote}"></label>`)}`,
+            input.localOwner?.eligible === true ? html ``
+                : input.localOwner != null ? html `<p class="approval-password-note" id="${parts.passwordNote}">${input.localOwner.message} <a href="${input.localOwner.href}">${input.localOwner.action}</a></p>`
+                    : input.freshSince == null ? html `<p class="approval-password-note" id="${parts.passwordNote}">Your password signs this approval.</p>`
+                        : html `<p class="approval-password-note" id="${parts.passwordNote}" data-approval-fresh>Your password from ${whenTime(input.freshSince)} is remembered on this computer — leave this blank to approve with it, or type it again.</p>`,
             html `<button type="submit" data-primary-action>${parts.submit}</button></div>`,
             html `<p class="approval-after">${parts.after}</p>`,
             html `<div class="approval-secondary">${parts.editor ?? html `<a class="approval-link" href="${input.editHref}">Edit plan</a>`}<a class="approval-link" href="${input.notNowHref}">Not now</a></div>`,
@@ -782,6 +784,9 @@ export function approvalProofWords(proof) {
         return " (from your paired chat)";
     if (proof.method === "carried")
         return " (carried from the release approval)";
+    // Easy-start C5: this computer's owner approving attended work in local mode, with no password.
+    if (proof.method === "local-owner")
+        return " (on this computer, no password)";
     return "";
 }
 const whenText = (iso) => new Intl.DateTimeFormat("en-US", { hour: "numeric", minute: "2-digit" }).format(new Date(iso));
@@ -1083,8 +1088,10 @@ export function decisionAnswerScript() {
         `var f=e.target;if(!f||!f.classList||!f.classList.contains("decide-inline"))return;` +
         `e.preventDefault();` +
         `var card=f.closest("[data-decision-id]");` +
-        `var page=f.action.replace(/\\/answer$/,"");` +
-        `fetch(f.action,{method:"POST",credentials:"same-origin",` +
+        // The action attribute, not f.action: a field named "action" would shadow that property (DOM clobbering).
+        `var to=new URL(HTMLFormElement.prototype.getAttribute.call(f,"action")||"",location.href).href;` +
+        `var page=to.replace(/\\/answer$/,"");` +
+        `fetch(to,{method:"POST",credentials:"same-origin",` +
         `headers:{"content-type":"application/x-www-form-urlencoded"},` +
         `body:new URLSearchParams(new FormData(f)).toString()})` +
         `.then(function(r){return r.text().then(function(t){return{r:r,t:t}})})` +
@@ -1651,6 +1658,7 @@ export function taskBodyParts(data) {
         nonce: data.nonce,
         digest: data.approvalDigest ?? scope.digest,
         freshSince: data.approvalFresh ?? null,
+        localOwner: data.approvalLocal ?? null,
         returnTo: null,
         scope,
         planDocument: data.plan === "drafted" ? data.planDocument : null,
@@ -2552,8 +2560,10 @@ export function approveKitOf(input, freshSince) {
         heading: rebuild !== null ? "The plan changed" : input.deliverable === "report" ? "Investigation ready" : "Plan ready",
         text: `Approving signs plan version ${input.scope.digest.slice(0, 12)} and ${after}.${allowing}`,
         kind: "standard",
-        facts: { passwordless: passwordlessRendering(), remembered: until !== null },
+        facts: { passwordless: passwordlessRendering() || input.localOwner?.eligible === true, remembered: until !== null },
         rememberedUntil: until,
+        // Easy-start C5: the owner approving on this computer needs no password, and the line says so (not "Passwordless").
+        ...(input.localOwner?.eligible === true ? { termsWords: "No password needed on this computer." } : {}),
         planHtml: htmlString(joinHtml([parts.lead, parts.rows, parts.editor ?? "", parts.details, parts.editorForm])),
     };
 }

package/dist/server/request-context.d.ts

@@ -45,6 +45,12 @@ export type RequestFacts = {
     passwordless?: boolean;
     /** The browser session's open project (display only: the sidebar's picker names it). */
     openProject?: string | null;
+    /** Easy start: a local owner with no password yet: every step-up field is the Set a password link instead (this href). */
+    localStepUp?: string;
+    /** Easy-start C2: the browser mutation key is required here, so every page that posts carries the key fill script. */
+    keyFill?: boolean;
+    /** Easy-start C2: this session's key is from an earlier console start (or it has none): how to reconnect. */
+    reconnect?: import("./mutation-key.js").Reconnect | null;
 };
 /**
  * The request's own session facts, readable from anywhere below the

package/dist/server/route-table.d.ts

@@ -16,6 +16,7 @@
  * admission: passwords, nonces, webhook signatures, object membership, stale
  * sessions and revoked tokens.
  */
+import type { LocalOwnerAct } from "../local-owner.js";
 /** Who presents the request. `service` is a verified external sender (a signed webhook, an OAuth return carrying its one-time state). */
 export type Caller = "anonymous" | "service" | "cookie" | "bearer" | "oauth" | "coordinator" | "lead";
 /** What the caller must hold: nothing, read, act (an approver or an `act` token), or a fresh password/provider check on top. */
@@ -86,7 +87,22 @@ export interface RouteDeclaration {
     /** Cockpit B2: whether a password remembered on this session may stand in here (`allowlist`), or never. Only the
      * allowlisted acts run their check inside `withFreshness` (scope.ts); every other step-up is `never`. */
     readonly freshness: "never" | "allowlist";
+    /**
+     * Easy-start C1: whether a local owner's session (a laptop install's passwordless owner) may use this row, decided for
+     * every row when the table loads (localMarkOf below). `allow` rows name the act they are (local-owner.ts
+     * LOCAL_OWNER_ACTS); the console's admission refuses a local owner everywhere else before the handler runs.
+     */
+    readonly local: "allow" | "deny";
+    readonly localAct: LocalOwnerAct | null;
 }
+/** Every edge row, decided: allow where a local owner's cookie may reach it, deny where its adapter refuses one (or no
+ * cookie is ever read there). A new edge row fails the table's load until it is listed here. */
+export declare const EDGE_LOCAL: Readonly<Record<string, {
+    local: "allow" | "deny";
+    why: string;
+}>>;
+/** The ids the local marks name, for the inventory test (a mark naming no row is stale). */
+export declare const LOCAL_MARKED_IDS: readonly string[];
 /** The sole route table, in match order. */
 export declare const ROUTES: readonly RouteDeclaration[];
 /** The first row that declares this method and path, or null: an undeclared request never reaches a handler. */

package/dist/server/route-table.js

@@ -45,8 +45,114 @@ function row(stage, domain, id, method, pattern, options = {}) {
         ...(options.roleRefusal === undefined ? {} : { roleRefusal: options.roleRefusal }),
         ...(options.bodyCap === undefined ? {} : { bodyCap: options.bodyCap }),
         freshness: options.freshness ?? "never",
+        ...localMarkOf(stage, method, id),
     });
 }
+// ---- easy-start C1: the local owner's marks --------------------------------------------------------------------------
+// Decided here for every row, failing the table's load for an edge row nobody decided. A console POST is refused to a
+// local owner unless LOCAL_POSTS names its act; a console GET is a read (`read`) unless LOCAL_GET_DENY names it.
+/** The console POST rows a local owner may use, and the act each is. Everything else is refused. */
+const LOCAL_POSTS = Object.freeze({
+    "tasks.add": "file-task",
+    "chat.file": "file-task",
+    "chat.send": "lead-send",
+    "chat.queued-remove": "lead-send",
+    "chat.mate-mint": "lead-send",
+    "chat.mate-follow": "lead-send",
+    "chat.mate-end": "lead-send",
+    "chat.mate-stop": "lead-send",
+    // The confirm door narrows the act to the card's own (lead-doors.ts: LOCAL_OWNER_PROPOSALS and the operation's act).
+    "chat.proposal.confirm": "lead-send",
+    "chat.proposal.dismiss": "lead-send",
+    "task.act.steer": "lead-send",
+    "task.act.approve": "approve-plan",
+    "decision.answer": "answer-question",
+    "task.act.reply": "answer-question",
+    "task.act.stop": "stop-run",
+    "task.act.cancel": "stop-run",
+    "task.act.hold": "pause-run",
+    "task.act.pause": "pause-run",
+    "task.act.unhold": "resume-run",
+    "task.act.resume-arm": "resume-run",
+    "task.act.resume": "resume-run",
+    "task.act.complete": "complete-task",
+    "run.act.revise": "request-revision",
+    "run.act.note": "request-revision",
+    "run.act.comment": "request-revision",
+    "task.act.archive": "archive-task",
+    "task.act.restore": "archive-task",
+    "projects.open": "add-project",
+    "projects.github-list": "add-project",
+    "projects.onboard-preview": "add-project",
+    "projects.onboard-confirm": "add-project",
+    // The welcome's sample project, added the way Projects adds a folder (the same admission and its re-check).
+    "welcome.sample": "add-project",
+    // The welcome's "Use this one" (and Settings → Lead's turn-on): the lead runs on Claude Code or Codex signed in here.
+    "settings.lead-on": "choose-default-agent",
+    // Choosing which open project the pages show: a view filter, never authorization.
+    "projects.select": "read",
+    "agents.seen": "mark-seen",
+    "agents.watch": "watch-agent",
+});
+/** Console GET rows refused to a local owner (none so far: every GET is a read; adapter-inventory.test.ts proves no GET
+ * writes beyond the allowlisted session touch and review nonce). */
+const LOCAL_GET_DENY = new Set([]);
+/** Every edge row, decided: allow where a local owner's cookie may reach it, deny where its adapter refuses one (or no
+ * cookie is ever read there). A new edge row fails the table's load until it is listed here. */
+export const EDGE_LOCAL = Object.freeze({
+    "edge.healthz": { local: "allow", why: "public read" },
+    "edge.instance": { local: "allow", why: "public read (the CLI proves the console)" },
+    "edge.telegram-hook": { local: "deny", why: "signed webhook; never a cookie" },
+    "edge.flow-form": { local: "deny", why: "a flow's public form; never a cookie" },
+    "edge.flow-form-send": { local: "deny", why: "a flow's public form; never a cookie" },
+    "edge.flow-hook": { local: "deny", why: "signed webhook; never a cookie" },
+    "edge.mcp": { local: "deny", why: "bearer only" },
+    "edge.oauth-discovery": { local: "allow", why: "public read" },
+    "edge.oauth-register": { local: "deny", why: "no cookie; registers a client only" },
+    "edge.oauth-token": { local: "deny", why: "OAuth client only" },
+    "edge.oauth-authorize": { local: "deny", why: "consent is a credential act: the adapter refuses a local owner's session" },
+    "edge.oauth-consent": { local: "deny", why: "consent is a credential act: the adapter refuses a local owner's session" },
+    "edge.google-callback": { local: "deny", why: "bound to state a refused settings POST starts" },
+    "edge.connect-callback": { local: "deny", why: "bound to state a refused settings POST starts" },
+    "edge.team-read": { local: "deny", why: "team conversations are a remote feature: authenticate refuses a local owner" },
+    "edge.team-send": { local: "deny", why: "team conversations are a remote feature: authenticate refuses a local owner" },
+    "edge.cli": { local: "deny", why: "bearer only" },
+    "edge.teams": { local: "deny", why: "signed service only" },
+    "edge.browser-asset": { local: "allow", why: "public asset" },
+    "edge.workspace-style": { local: "allow", why: "public asset" },
+    "edge.install-asset": { local: "allow", why: "public asset" },
+    "edge.font": { local: "allow", why: "public asset" },
+    "edge.desktop-health": { local: "allow", why: "public read" },
+    "edge.login-page": { local: "allow", why: "before sign-in" },
+    "edge.login-link": { local: "allow", why: "before sign-in: a one-time link" },
+    "edge.sso-start": { local: "allow", why: "before sign-in" },
+    "edge.sso-callback": { local: "allow", why: "before sign-in" },
+    "edge.sso-finish": { local: "allow", why: "before sign-in" },
+    "edge.signup": { local: "allow", why: "before sign-in" },
+    "edge.login": { local: "allow", why: "before sign-in: a password typed now makes a full session" },
+    "edge.logout": { local: "allow", why: "only narrows: ends this session" },
+    "edge.join": { local: "allow", why: "before sign-in: an invitation" },
+    "edge.join-send": { local: "allow", why: "before sign-in: an invitation" },
+    "edge.rekey-page": { local: "allow", why: "reads only: a local owner is told to run `toolroll open`" },
+    "edge.rekey": { local: "allow", why: "only a password typed now re-keys a full session; a local owner is told to run `toolroll open` and gets no key" },
+    "edge.password-set-page": { local: "allow", why: "reads only: the local owner's form for a first password, or \"already set — sign in\"" },
+    "edge.password-set": { local: "allow", why: "the one credential act a local owner may make: its first password (Origin, CSRF and key proved by the handler; enrollOwnerPassword re-checks local mode, the owner and password_set=0 in its own transaction); a session with a password set is refused" },
+    live: { local: "allow", why: "observational only; the agent watch lease is a keyed POST (agents.watch)" },
+});
+function localMarkOf(stage, method, id) {
+    if (stage === "edge") {
+        const decided = Object.prototype.hasOwnProperty.call(EDGE_LOCAL, id) ? EDGE_LOCAL[id] : undefined;
+        if (decided === undefined)
+            throw new Error(`route table: edge row ${id} has no local-owner mark (EDGE_LOCAL)`);
+        return { local: decided.local, localAct: decided.local === "allow" ? "read" : null };
+    }
+    if (method !== "POST")
+        return LOCAL_GET_DENY.has(id) ? { local: "deny", localAct: null } : { local: "allow", localAct: "read" };
+    const act = Object.prototype.hasOwnProperty.call(LOCAL_POSTS, id) ? LOCAL_POSTS[id] : null;
+    return act === null ? { local: "deny", localAct: null } : { local: "allow", localAct: act };
+}
+/** The ids the local marks name, for the inventory test (a mark naming no row is stale). */
+export const LOCAL_MARKED_IDS = Object.freeze([...Object.keys(LOCAL_POSTS), ...LOCAL_GET_DENY, ...Object.keys(EDGE_LOCAL)]);
 const edge = (domain, id, method, path, options = {}) => row("edge", domain, id, method, path.startsWith("^") ? path : exact(path), options);
 const get = (domain, id, path, options = {}) => row("console", domain, id, "GET", path.startsWith("^") ? path : exact(path), options);
 const post = (domain, id, path, options = {}) => row("console", domain, id, "POST", path.startsWith("^") ? path : exact(path), options);
@@ -100,6 +206,12 @@ edge("people", "edge.sso-finish", "GET", "/login/sso/finish");
 edge("people", "edge.signup", "POST", "/signup");
 edge("people", "edge.login", "POST", "/login");
 edge("people", "edge.logout", "POST", "/logout", { callers: ["anonymous", "cookie"] });
+// Easy-start C2: a browser session's fresh mutation key after a restart: its own password again (the handler proves both).
+edge("people", "edge.rekey-page", "GET", "/login/rekey", { callers: ["anonymous", "cookie"] });
+edge("people", "edge.rekey", "POST", "/login/rekey", { callers: ["anonymous", "cookie"] });
+// Easy-start C4: the local owner sets a first password (only while none is set); the answer is a fresh full session.
+edge("people", "edge.password-set-page", "GET", "/password/set", { callers: ["anonymous", "cookie"] });
+edge("people", "edge.password-set", "POST", "/password/set", { callers: ["anonymous", "cookie"] });
 edge("people", "edge.join", "GET", "^\\/join\\/[A-Za-z0-9_-]{16,64}$", { sample: "/join/abcdefghijklmnop" });
 edge("people", "edge.join-send", "POST", "^\\/join\\/[A-Za-z0-9_-]{16,64}$", { sample: "/join/abcdefghijklmnop" });
 // ---- console reads ---------------------------------------------------------------------------------------------
@@ -165,6 +277,8 @@ get("pages", "fleet", "/fleet", free);
 get("tasks", "tasks.new", "/tasks/new", { limited: "collection", ...free });
 // The first run's own page (Wave E): five guided steps, reads only; it leads Home once the first run is over.
 get("tasks", "welcome", "/welcome", { limited: "collection", ...free });
+// Try a sample project (first-run.ts, sample-project.ts): made in the project folder, then added the way Projects adds a folder.
+post("tasks", "welcome.sample", "/welcome/sample", { callers: ["cookie"], project: "none", ...approver("An approver adds projects.", "/welcome") });
 get("tasks", "task.page", `^\\/t\\/${TASK}$`, { project: "task", limited: "resource", ...free, sample: "/t/one" });
 get("tasks", "task.evidence", `^\\/t\\/${TASK}\\/evidence$`, { project: "task", limited: "resource", ...free, sample: "/t/one/evidence" });
 get("pages", "ledger.export", "/ledger/export", { limited: "unscoped", ...free });
@@ -329,6 +443,8 @@ post("tasks", "sweep.cancel-rest", "^\\/sweeps\\/[1-9][0-9]{0,9}\\/cancel-rest$"
 // (the handler proves it as a credential act); turning it off is one click, so the row itself is not a step-up.
 get("settings", "settings.passwordless", "/settings/passwordless", { ...free, ...operator("An instance operator sets Passwordless.", "/settings") });
 post("settings", "settings.passwordless-send", "/settings/passwordless", { callers: ["cookie"], ...operator("An instance operator sets Passwordless.", "/settings") });
+// Easy-start C5: turning local mode off: an instance operator's step-up from a full session (a local owner is refused).
+post("settings", "settings.local-mode-off", "/settings/local-mode/off", { callers: ["cookie"], scope: "step-up", ...operator("An instance operator turns off local mode.", "/settings/access") });
 // Release approval (docs/plans/auto-approve-green.md): an approver of the project, from a browser. Approving releases
 // automatically takes a typed password (the handler proves it as a credential act); asking again is one click.
 post("settings", "settings.release-approval-send", "/settings/release-approval", { callers: ["cookie"], ...approver("An approver sets how releases are approved.", "/settings/approval") });
@@ -473,6 +589,11 @@ for (const one of ["note", "comment", "revise", "draft-repair", "checks", "add-t
 // Cockpit E: reveal a running attempt's proved checkout in Finder (nothing is launched in it).
 post("tasks", "run.act.reveal", `^\\/r\\/${ID}\\/reveal$`, { project: "run", limited: "resource", callers: ["cookie"], sample: "/r/1/reveal", ...approver("Only an approver can show an agent's files.") });
 post("tasks", "session.editor-links", "/session/editor-links", { viewer: true });
+// Easy-start C1 (N1): reads never write. The shell says a finished result was opened (it leaves the person's unread
+// Done), and holds or releases the short lease that quiets chat pings while an agent's page is open — keyed POSTs, never
+// a page load or the live stream. A watch-only account keeps its own seen marks and watches too.
+post("tasks", "agents.seen", "/agents/seen", { callers: ["cookie"], project: "none", limited: "unscoped", viewer: true });
+post("tasks", "agents.watch", "/agents/watch", { callers: ["cookie"], project: "none", limited: "unscoped", viewer: true });
 post("tasks", "incident.resolve", `^\\/i\\/${ID}\\/resolve$`, { project: "incident", sample: "/i/1/resolve" });
 /** The sole route table, in match order. */
 export const ROUTES = Object.freeze(rows.map(one => Object.freeze(one)));

package/dist/server/runtime.d.ts

@@ -210,6 +210,7 @@ export interface ServerRuntime {
     authorizeMutation: (request: IncomingMessage, who: Who, body: FormView<FormFieldOf<"mutationGuard">>) => {
         status: number;
         message: string;
+        reconnect?: import("./mutation-key.js").Reconnect;
     } | null;
     leadSaid: Map<string, {
         turn: number | null;
@@ -245,10 +246,11 @@ export interface ServerRuntime {
         label: string;
         operatorsOnly: boolean;
     } | null;
-    signInLinks: Map<string, {
-        account: string;
-        expires: number;
-    }>;
+    signInLinks: Map<string, import("./session.js").SignInLink>;
+    /** v147: this console start's key epoch (easy-start C2). */
+    keyEpoch: string;
+    /** Easy-start C2: the browser mutation key (server/mutation-key.ts): the one check, issuing and delivering a key. */
+    browserKeys: import("./mutation-key.js").BrowserKeys;
     linkKey: (code: string) => string;
     fromThisComputer: (request: IncomingMessage) => boolean;
     /** Cockpit B2: the request's live password-freshness facts (null off a browser session). */

package/dist/server/session.d.ts

@@ -2,6 +2,7 @@
 import { type ChatDraft } from "../converse.js";
 import { type Principal } from "../operate-remote.js";
 import { type Store } from "../store.js";
+import { type Authority } from "../local-owner.js";
 import { type Server } from "node:http";
 /** A user agent, reduced to safe display words — never echoed raw. */
 export declare function oneLineUa(raw: string | string[] | undefined): string;
@@ -27,6 +28,14 @@ export declare const NO_TOUCH_FRAGMENTS: ReadonlySet<string>;
 export type Session = {
     name: string;
     csrf: string;
+    /** v147 (easy-start C1): full, or the local owner's restricted authority. Set when the session is made; never changed. */
+    authority: Authority;
+    /** v147: a local owner's session stands only while local mode is on at this generation (null for a full session). */
+    localGeneration: number | null;
+    /** v147 (C2, filled in by the browser-key wave): the console start whose mutation key this session holds, and a hash of
+     * that key (never the key). Null: no key yet, or a session saved before v147 — stale, so mutations ask to reconnect. */
+    keyEpoch: string | null;
+    keyHash: string | null;
     /** v29: the account's standing at login — the central gate reads it;
      * the revocation cascade kills the session outright. */
     role: "approver" | "viewer";
@@ -108,7 +117,8 @@ export type Who = {
     name: string;
     via: "cookie";
     session: Session;
-    role: "approver" | "viewer";
+    role: "approver" | "viewer"; /** v147: the session's own authority. */
+    authority: Authority;
 } | {
     name: string;
     via: "bearer";
@@ -117,6 +127,11 @@ export type Who = {
     /** The complete proved API-token authority, retained across body reads. */ principal?: Principal;
     generation: number;
 };
+/** A full session's authority fields when it is made (a password, an identity-provider sign-in, a sign-up or join).
+ * The browser-key wave adds the key epoch and hash here. */
+export declare const FULL_SESSION: Pick<Session, "authority" | "localGeneration" | "keyEpoch" | "keyHash">;
+/** A caller's authority: a browser session's own, or full for a bearer credential (an API token or a password). */
+export declare function authorityOfWho(who: Who): Authority;
 /** The browser session of a caller its route admits only through a browser sign-in (the row's callers or role). */
 export declare function browserCaller(who: Who): Extract<Who, {
     via: "cookie";
@@ -157,6 +172,21 @@ export declare class PersistentSessions extends Map<string, Session> {
  * closeCoding starts the coding shutdown on its own, ahead of the rest of a stop; close() awaits the same promise. */
 export type DecisionServer = Server & {
     mintSignInLink(account: string): string | null;
+    mintLocalLink(): string | null;
+    readonly keyEpoch: string;
     closeCoding(): Promise<void>;
 };
+/** A one-time sign-in link as the console holds it (only a hash of its code is the key): a full one for an account,
+ * or a local owner's (easy-start C4), bound to local mode's generation and the owner's account generation when minted. */
+export type SignInLink = {
+    kind: "full";
+    account: string;
+    expires: number;
+} | {
+    kind: "local-owner";
+    account: string;
+    localGeneration: number;
+    accountGeneration: number;
+    expires: number;
+};
 export type SsoIntent = "sign-in" | "reauth" | "link";

package/dist/server/session.js

@@ -2,6 +2,7 @@
 import {} from "../converse.js";
 import {} from "../operate-remote.js";
 import {} from "../store.js";
+import {} from "../local-owner.js";
 import { createHash } from "node:crypto";
 import {} from "node:http";
 /** A user agent, reduced to safe display words — never echoed raw. */
@@ -33,6 +34,13 @@ export const NONCE_TTL_MS = 15 * 60_000;
 export const NONCE_CAP = 500;
 /** Read-only fragment polls that must never refresh session activity (arc 1). */
 export const NO_TOUCH_FRAGMENTS = new Set(["1", "facts", "peek", "rail", "transcript"]);
+/** A full session's authority fields when it is made (a password, an identity-provider sign-in, a sign-up or join).
+ * The browser-key wave adds the key epoch and hash here. */
+export const FULL_SESSION = Object.freeze({ authority: "full", localGeneration: null, keyEpoch: null, keyHash: null });
+/** A caller's authority: a browser session's own, or full for a bearer credential (an API token or a password). */
+export function authorityOfWho(who) {
+    return who.via === "cookie" ? who.authority : "full";
+}
 /** The browser session of a caller its route admits only through a browser sign-in (the row's callers or role). */
 export function browserCaller(who) {
     if (who.via !== "cookie")
@@ -59,7 +67,8 @@ export class PersistentSessions extends Map {
         this.ids.set(session, id);
         this.savedAt.set(session, Date.now());
         this.db.saveWebSession({ idHash: PersistentSessions.hash(id), account: session.name, csrf: session.csrf, role: session.role, generation: session.generation, createdAt: session.createdAt,
-            lastSeen: session.lastSeen, project: session.project, projectRevision: session.projectRevision, ssoAt: session.sso?.at ?? null, agent: session.agent ?? null, address: session.address ?? null });
+            lastSeen: session.lastSeen, project: session.project, projectRevision: session.projectRevision, ssoAt: session.sso?.at ?? null, agent: session.agent ?? null, address: session.address ?? null,
+            authority: session.authority, localGeneration: session.localGeneration, keyEpoch: session.keyEpoch, keyHash: session.keyHash });
         return this;
     }
     delete(id) {
@@ -89,7 +98,8 @@ export class PersistentSessions extends Map {
         if (row === null)
             return null;
         const session = { name: row.account, csrf: row.csrf, role: row.role, generation: row.generation, createdAt: row.createdAt, lastSeen: row.lastSeen, sawBoardAt: null,
-            project: row.project, projectRevision: row.projectRevision, agent: row.agent, address: row.address, ...(row.ssoAt === null ? {} : { sso: { at: row.ssoAt } }) };
+            project: row.project, projectRevision: row.projectRevision, agent: row.agent, address: row.address, ...(row.ssoAt === null ? {} : { sso: { at: row.ssoAt } }),
+            authority: row.authority, localGeneration: row.localGeneration, keyEpoch: row.keyEpoch, keyHash: row.keyHash };
         super.set(id, session);
         this.ids.set(session, id);
         this.savedAt.set(session, Date.now());

package/dist/server/settings.js

@@ -76,7 +76,7 @@ import { startConnect } from "../mcp-connect.js";
 import { decideProposal, listProposals, memoryStatus } from "../memory-pass.js";
 import { checkModels, isNewModel, modelOptions, modelWords, RUNTIME_TOOLS, runtimeStates, seenModels, setWatch, updateRuntime, watchState } from "../model-catalog.js";
 import { modelsHtml, modelsScript } from "../models-ui.js";
-import { ALL_SLOTS, applyModelChoices, browserWords, checkScope, DEFAULT_PRESET, isPresetName, newerModels, PRESETS, presetChange, presetInUse, previewModelChange, recentRuns, rowAt, slotKey, SLOTS, slotWords, stateDigest, switchChange } from "../model-choices.js";
+import { ALL_SLOTS, applyModelChoices, browserWords, checkScope, DEFAULT_PRESET, defaultAgentOf, fillDefaultRouting, isPresetName, newerModels, PRESETS, presetChange, presetInUse, previewModelChange, recentRuns, rowAt, slotKey, SLOTS, slotWords, stateDigest, switchChange } from "../model-choices.js";
 import { HEADROOM_FIVE_HOUR_LIMIT, HEADROOM_WEEKLY_LIMIT, exactModelId } from "../phase-routing.js";
 import { RISKY_MEANS, SIZE_MEANS, SIZING_CLAUDE_MODEL } from "../task-sizing.js";
 import { CHAT_APPROVE_ALL, MODE_MAX_DAYS, modeDigestOf, modeTermsJson, modeWords, presetTerms } from "../modes.js";
@@ -89,6 +89,7 @@ import { parseProjectConcurrency, saveProjectConcurrency } from "../project-conc
 import { MAX_NETWORK_HOSTS, normalizeHost } from "../egress.js";
 import { isWritesMode } from "../writes-mode.js";
 import { isCheckAccess, signInsUnavailableWords, widerThan } from "../check-access.js";
+import { LOCAL_MODE_CONFINES, localModeOn } from "../local-owner.js";
 import { parseMachLookup, parseReadDeny } from "../project-sandbox.js";
 import { projectDeleteConfirmHtml, projectSettingsHtml } from "../project-delete-ui.js";
 import { deleteProject, holdingsWords } from "../project-delete.js";
@@ -126,7 +127,7 @@ import { sweepSchedule } from "../storage-sweep-schedule.js";
 import { storageHtml } from "../storage-ui.js";
 import { landedSummary } from "../landed-cleanup.js";
 import { bytesWords, parseCleanup } from "../storage.js";
-import { isDigestTime, liveBackupState, RESULT_SCREENSHOTS, setLiveBackupSettings } from "../store.js";
+import { isDigestTime, liveBackupState, localModeOf, RESULT_SCREENSHOTS, setLiveBackupSettings, setLocalModeOff } from "../store.js";
 import { defaultLiveFolder, liveFolderOf, liveFolderProblem } from "../live-backup.js";
 import { LIVE_EVERY } from "../backup-ui.js";
 import { checkTeamsCredentials, clearTeamsCredentials, loadTeamsCredentials, saveTeamsCredentials, TeamsError } from "../teams-api.js";
@@ -775,6 +776,12 @@ ${repositoryContextHtml(chosen, query, result, who.role === 'approver' ? csrf :
                 return null;
             } })() : null,
             access: { sessions: store.webSessions(who.name).length, tokens: store.apiTokens(who.name).filter(one => one.revokedAt === null && Date.parse(one.expiresAt) > now.getTime()).length },
+            local: (() => {
+                const mode = localModeOf(store);
+                if (mode === null || !mode.enabled || who.via !== "cookie")
+                    return null;
+                return { owner: who.authority !== "full", passwordSet: store.accountOf(who.name)?.passwordSet === true, canTurnOff: who.authority === "full" && operator };
+            })(),
             backup: lastBackup === null ? null : lastBackup.ok === false
                 ? { failed: true, words: `Failed ${when(lastBackup.startedAt)}${lastBackup.error === null ? "" : `: ${lastBackup.error}`}` }
                 : { failed: false, words: lastBackup.finishedAt === null ? "Backing up now" : `Backed up ${when(lastBackup.finishedAt)}` },
@@ -2448,14 +2455,35 @@ ${postForm("/settings/chat-approval/save", html `\
     }
     // Turn the lead on with the agent signed in on this computer: its membership spends no dollars, so like starting a
     // conversation it needs no second password; the full form (Advanced) still asks for one.
+    // The welcome's "Use this one" names the agent (`agent`, claude or codex: only one signed in with its account here)
+    // and comes back to the welcome (`return`, that one address only).
     async function leadOn(ctx) {
-        const { who, response, now } = ctx;
+        const { who, response, now, posted } = ctx;
+        const body = readForm(posted, CONSOLE_FORMS.leadOn);
+        const asked = body.get("agent");
+        if (body.sent.getAll("agent").length > 1 || (asked !== null && asked !== "claude" && asked !== "codex"))
+            return refuse(response, who, 400, "Choose Claude Code or Codex.", "/settings/lead");
+        const back = body.get("return") === "/welcome" ? "/welcome" : null;
         await checkLocalAgents(true);
-        const provider = runtime.localSignIn?.states.claude === "connected" ? "claude-subscription" : runtime.localSignIn?.states.codex === "connected" ? "codex-subscription" : null;
-        if (provider === null)
-            return redirect(response, chatReturnWithSaid("/settings/lead", `No agent is signed in on this computer yet. Run ${agentSignInCommand()}, then try again.`));
-        store.setChatConfig({ provider, model: "default", dailyTurns: 50, weeklyCeilingMicrousd: 0, priceInMicrousd: 0, priceOutMicrousd: 0 }, who.name, now);
-        return redirect(response, "/chat");
+        const states = runtime.localSignIn?.states;
+        const provider = asked !== null ? (states?.[asked] === "connected" ? `${asked}-subscription` : null)
+            : states?.claude === "connected" ? "claude-subscription" : states?.codex === "connected" ? "codex-subscription" : null;
+        if (provider === null) {
+            const words = asked === null ? `No agent is signed in on this computer yet. Run ${agentSignInCommand()}, then try again.` : `${asked === "claude" ? "Claude Code" : "Codex"} isn't signed in on this computer yet.`;
+            return redirect(response, back ?? chatReturnWithSaid("/settings/lead", words));
+        }
+        // Choosing the one already in use changes nothing (its daily turns and the rest stay as set). The local owner's
+        // choice also starts the installation's models on that agent's default preset, in the same write, while nothing
+        // is chosen yet (model-choices.ts fillDefaultRouting): its first task can then be planned and approved without a
+        // password. A full session's choice is as before: its models are Settings → Models'.
+        store.transact(() => {
+            if (store.getChatConfig()?.provider !== provider)
+                store.setChatConfig({ provider, model: "default", dailyTurns: 50, weeklyCeilingMicrousd: 0, priceInMicrousd: 0, priceOutMicrousd: 0 }, who.name, now);
+            const agent = defaultAgentOf(provider);
+            if (who.via === "cookie" && who.authority === "local-owner" && agent !== null)
+                fillDefaultRouting(store, agent, who.name, { kind: "local-owner" }, now);
+        });
+        return redirect(response, back ?? "/chat");
     }
     /** Settings → Models, read from the saved catalog and the role rows at the scope being edited (the installation,
      * or one project and what it inherits). */
@@ -2648,6 +2676,7 @@ ${postForm("/settings/chat-approval/save", html `\
         "settings.sign-in": signInPage,
         "settings.passwordless": passwordlessPage,
         "settings.passwordless-send": passwordlessSave,
+        "settings.local-mode-off": localModeOff,
         "settings.release-approval-send": releaseApprovalSave,
         "settings.lead": leadPage,
         "settings.teams": teamsPage,
@@ -2804,6 +2833,9 @@ ${postForm("/settings/chat-approval/save", html `\
         if (unavailable !== null)
             return back("problem", `${unavailable} Nothing changed.`);
         const widening = widerThan(wanted, store.projectCheckAccess(repo));
+        // Easy-start C5: while local mode is on, this installation always confines; said before the password.
+        if (wanted === "unsandboxed" && localModeOn(store))
+            return back("problem", `${LOCAL_MODE_CONFINES} Nothing changed.`);
         // Sign-ins with an open network: a second, explicit yes, said before the password.
         if (wanted === "sign-ins" && widening && store.projectNetwork(repo).mode === "open" && body.get("confirm-open") !== "yes") {
             return back("problem", "This project's network is open: confirm that its checks could send your sign-ins to any host. Nothing changed.");
@@ -2950,5 +2982,28 @@ ${postForm("/settings/chat-approval/save", html `\
         const said = modelsSaid(result, isPresetName(preset) ? PRESETS[preset].label : `Switched to ${to}`);
         return back(said.key, said.words);
     }
+    // Easy-start C5: turning local mode off (Settings → People and sign-in), from a full session only: an instance
+    // operator's step-up, proved and written in one transaction. It bumps local mode's generation, so every local-owner
+    // session, link and approval bound to the old one stops standing. It is never turned back on here.
+    async function localModeOff(ctx) {
+        const { response, now, posted } = ctx;
+        const who = browserCaller(ctx.who);
+        const body = readForm(posted, CONSOLE_FORMS.localModeOff);
+        const back = sayTo(response, "/settings/access", "#local-mode");
+        if (body.sent.getAll("password").length > 1)
+            return back("problem", "That form was sent twice over. Nothing changed.");
+        if (who.authority !== "full")
+            return back("problem", "Sign in with your password to turn off local mode.");
+        const turned = store.transact(() => {
+            if (!authenticateApprover(who, body.get("password") ?? "").ok)
+                return null;
+            return setLocalModeOff(store, { name: who.name, authority: who.authority }, now);
+        });
+        if (turned === null)
+            return back("problem", "Enter your Toolroll password to turn off local mode.");
+        if (!turned.ok)
+            return back("problem", turned.reason === "not-on" ? "Local mode is already off." : "Only an instance operator can turn off local mode.");
+        return back("said", "Local mode is off. This computer's browser signs in with your password now.");
+    }
     return { registrations, modelsView };
 }

package/dist/server/task-views.js

@@ -5,7 +5,8 @@ import { RELEASE_STEPS } from "../release.js";
 import { releaseProgressFor, shipChecksForTask } from "../store.js";
 import { releaseCiRunningOf } from "../release-ci-hold.js";
 import { releaseObligationsOf } from "../release-recheck.js";
-import { approvalProofOf, freshlyApprovable, freshnessFor, withFreshness } from "../scope.js";
+import { approvalProofOf, freshlyApprovable, freshnessFor, localApprovalEligible, withFreshness } from "../scope.js";
+import { localOwnerRefusal } from "../local-owner.js";
 import { liveAttemptOf, steerControlsFor } from "../steer-controls.js";
 import { originOf } from "../task-source.js";
 import { recentGitReads, taskBaseOf } from "../task-base.js";
@@ -526,6 +527,14 @@ export function createTaskViews(runtime) {
                 const gate = runtime.store.approvalGate(ref.externalId, who.name, "person");
                 return freshlyApprovable(runtime.store, ref.externalId, scope, gate.verdict === "seal" && !gate.protectedWork) ? new Date(fresh.at).toISOString() : null;
             })(),
+            // Easy-start C5: a laptop's local owner approves eligible work with no password (the seal applies the same rule).
+            approvalLocal: (() => {
+                if (ref === null || who?.via !== "cookie" || who.authority !== "local-owner")
+                    return null;
+                if (localApprovalEligible(runtime.store, who.name, ref.externalId).ok)
+                    return { eligible: true };
+                return { eligible: false, ...localOwnerRefusal(runtime.store.accountOf(who.name)?.passwordSet === true, taskHref(ref.externalId)) };
+            })(),
             steerRecent: ref === null ? [] : runtime.store.runsFor(ref.id).filter(one => one.outcome !== null).map(one => one.id).sort((a, b) => b - a).slice(0, 5),
             // The running attempt's composer, for an approver on a browser session (steer-controls.ts).
             steerComposer: (() => {

package/dist/server/tasks.d.ts

@@ -54,3 +54,13 @@ export declare function createTidyHandlers(runtime: ServerRuntime): {
 export declare function retiredTasksAddress(route: "board" | "done", url: URL): string | null;
 /** How many cards a Board column shows; the column's count covers them all and its "View all" opens the list. */
 export declare const BOARD_COLUMN_LIMIT = 40;
+/**
+ * Easy-start C1 (N1): the two writes a page load used to make, as keyed POSTs the shell sends (wave 1c wires the
+ * browser). `agents.seen`: a finished result this person opened leaves their unread Done. `agents.watch`: hold (on each
+ * keep-alive) or release (on unload) the short lease that quiets chat pings while this person's page shows the agent.
+ * Each re-proves the run is in the person's projects; a reply carries nothing else.
+ */
+export declare function createAgentSignalHandlers(runtime: ServerRuntime): {
+    "agents.seen": (ctx: HandlerContext) => Promise<void>;
+    "agents.watch": (ctx: HandlerContext) => Promise<void>;
+};