toolroll 0.9.6 → 0.9.8

package/dist/review-switch.js

@@ -0,0 +1,88 @@
+export const REVIEW_SCHEMA = `
+-- A project's explicit review switch. No row: on while the project is under a hands-off mode, off otherwise.
+CREATE TABLE IF NOT EXISTS review_switch (
+  repo        TEXT PRIMARY KEY,
+  enabled     INTEGER NOT NULL CHECK (enabled IN (0, 1)),
+  changed_by  TEXT NOT NULL,
+  changed_at  TEXT NOT NULL
+);
+-- One row per reviewed build run: pending until its one reviewer run settles it.
+CREATE TABLE IF NOT EXISTS build_review (
+  run           INTEGER PRIMARY KEY,
+  task_id       TEXT NOT NULL,
+  repo          TEXT NOT NULL,
+  state         TEXT NOT NULL CHECK (state IN ('pending', 'reviewed', 'not-reviewed')),
+  request       INTEGER,
+  reviewer_run  INTEGER,
+  findings_json TEXT,
+  reason        TEXT,
+  sent_back_as  TEXT,
+  queued_at     TEXT NOT NULL,
+  finished_at   TEXT
+);
+CREATE INDEX IF NOT EXISTS build_review_pending ON build_review (repo) WHERE state = 'pending';
+CREATE INDEX IF NOT EXISTS build_review_sent_back ON build_review (sent_back_as) WHERE sent_back_as IS NOT NULL;
+`;
+/** How the policy log words a switch state. */
+export function reviewSwitchWords(state) {
+    return state.source === "project" ? (state.on ? "on" : "off") : state.on ? "on (hands-off default)" : "off (default)";
+}
+export function buildReviewOf(store, runId) {
+    let row;
+    // A deploy reads this with the candidate's code over the INSTALLED runtime's file, before this version's migration
+    // made the table: no table reads as no review.
+    try {
+        row = store.handle.prepare("SELECT * FROM build_review WHERE run = ?").get(runId);
+    }
+    catch (error) {
+        if (/no such table: build_review/.test(String(error)))
+            return null;
+        throw error;
+    }
+    if (row === undefined)
+        return null;
+    // The row was validated when it was written (parseBuildFindings).
+    let findings = [];
+    try {
+        const saved = row["findings_json"] === null ? null : JSON.parse(String(row["findings_json"]));
+        if (Array.isArray(saved?.findings))
+            findings = saved.findings;
+    }
+    catch { /* An unreadable saved row shows no findings; its state stays. */ }
+    return {
+        run: runId,
+        state: String(row["state"]),
+        reviewerRun: row["reviewer_run"] === null ? null : Number(row["reviewer_run"]),
+        reason: row["reason"] === null ? null : String(row["reason"]),
+        high: findings.filter(one => one.severity === "HIGH"),
+        followUps: findings.filter(one => one.severity !== "HIGH"),
+        sentBackAs: row["sent_back_as"] === null ? null : String(row["sent_back_as"]),
+        finishedAt: row["finished_at"] === null ? null : String(row["finished_at"]),
+    };
+}
+export const findingWords = (finding) => `${finding.severity} ${finding.file}:${finding.line} — ${finding.scenario}`;
+/** The review's standing in one line, or null while nothing was asked. */
+export function buildReviewHeadline(view) {
+    if (view === null)
+        return null;
+    if (view.state === "pending")
+        return "Reviewing — an automatic review is reading this result.";
+    if (view.state === "not-reviewed")
+        return `Not reviewed${view.reason === null ? "." : `: ${view.reason}`}`;
+    if (view.sentBackAs !== null)
+        return `Sent back as ${view.sentBackAs}: ${view.high.length} high finding${view.high.length === 1 ? "" : "s"}.`;
+    if (view.high.length > 0)
+        return `Reviewed: ${view.high.length} high finding${view.high.length === 1 ? "" : "s"} for you to decide.`;
+    return `Reviewed: no high findings${view.followUps.length === 0 ? "." : `; ${view.followUps.length} suggested follow-up${view.followUps.length === 1 ? "" : "s"}.`}`;
+}
+/** Plain lines for `task show` and `assignment show`. */
+export function buildReviewLines(view) {
+    const headline = buildReviewHeadline(view);
+    if (view === null || headline === null)
+        return [];
+    return [
+        `  review: ${headline}`,
+        ...view.high.map(one => `    ${findingWords(one)}`),
+        ...view.followUps.map(one => `    suggested follow-up: ${findingWords(one)}`),
+    ];
+}

package/dist/reviewer.d.ts

@@ -1,6 +1,8 @@
-/** Pure parser for retained historical review payloads. Model-review execution
- * is retired; this module cannot launch providers, create runs or retry work. */
+/** Pure parsers for review payloads: retained historical reviews, and the one
+ * automatic build review's findings (build-review.ts runs it). This module
+ * cannot launch providers, create runs or retry work. */
 import type { CriterionJudgementWord } from "./proof.js";
+import type { BuildFinding } from "./review-switch.js";
 /** The files the pass writes INTO the scratch directory for the agent —
  * the patch always; the rubric, re-serialized proof, check log, and
  * screenshots only when this run actually has one (v40) — a grandfathered
@@ -95,3 +97,23 @@ export declare function parseReview(raw: string, patchPaths: ReadonlySet<string>
     ok: false;
     problems: ReviewProblem[];
 };
+export type { BuildFinding, FindingSeverity } from "./review-switch.js";
+export declare const FINDING_LIMITS: {
+    readonly findings: 40;
+    readonly file: 300;
+    readonly scenario: 500;
+};
+/**
+ * The automatic build review's reply, strict and wholesale like parseReview:
+ * `{"version":1,"findings":[{"severity","file","line","scenario"}]}`. Any
+ * invalid finding refuses the whole reply — a review that did not answer
+ * what it was asked is "not reviewed", never a partial pass. Text is kept
+ * to one line so it can travel in a revision note and a terminal.
+ */
+export declare function parseBuildFindings(raw: string): {
+    ok: true;
+    findings: BuildFinding[];
+} | {
+    ok: false;
+    problem: string;
+};

package/dist/reviewer.js

@@ -1,5 +1,5 @@
 import { citesSuppliedProvenance } from "./review-context.js";
-import { REVIEW_OUTPUT_LIMITS } from "./structured-output.js";
+import { normalizeStructuredJson, REVIEW_OUTPUT_LIMITS } from "./structured-output.js";
 /** The files the pass writes INTO the scratch directory for the agent —
  * the patch always; the rubric, re-serialized proof, check log, and
  * screenshots only when this run actually has one (v40) — a grandfathered
@@ -200,3 +200,51 @@ export function parseReview(raw, patchPaths, approvedCriteriaIds = new Set(), pr
         return { ok: false, problems };
     return { ok: true, comments, criteria, ...(payload["learning"] === undefined ? {} : { learning: payload["learning"] }), ...(payload["learningAssessment"] === undefined ? {} : { learningAssessment: payload["learningAssessment"] }) };
 }
+export const FINDING_LIMITS = { findings: 40, file: REVIEW_OUTPUT_LIMITS.path, scenario: REVIEW_OUTPUT_LIMITS.note };
+/**
+ * The automatic build review's reply, strict and wholesale like parseReview:
+ * `{"version":1,"findings":[{"severity","file","line","scenario"}]}`. Any
+ * invalid finding refuses the whole reply — a review that did not answer
+ * what it was asked is "not reviewed", never a partial pass. Text is kept
+ * to one line so it can travel in a revision note and a terminal.
+ */
+export function parseBuildFindings(raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(normalizeStructuredJson(raw).text);
+    }
+    catch {
+        return { ok: false, problem: "the reply is not JSON" };
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        return { ok: false, problem: "the reply is not an object" };
+    const payload = parsed;
+    if (payload["version"] !== 1)
+        return { ok: false, problem: "version must be 1" };
+    const list = payload["findings"];
+    if (!Array.isArray(list))
+        return { ok: false, problem: "findings must be an array" };
+    if (list.length > FINDING_LIMITS.findings)
+        return { ok: false, problem: `at most ${FINDING_LIMITS.findings} findings` };
+    const findings = [];
+    const oneLine = (text) => text.replace(/[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]+/g, " ").replace(/\s+/g, " ").trim();
+    for (const [index, one] of list.entries()) {
+        if (one === null || typeof one !== "object" || Array.isArray(one))
+            return { ok: false, problem: `finding ${index}: not an object` };
+        const finding = one;
+        const severity = finding["severity"];
+        if (severity !== "HIGH" && severity !== "MEDIUM" && severity !== "LOW")
+            return { ok: false, problem: `finding ${index}: severity must be HIGH, MEDIUM or LOW` };
+        const file = typeof finding["file"] === "string" ? oneLine(finding["file"]) : "";
+        if (file.length === 0 || file.length > FINDING_LIMITS.file)
+            return { ok: false, problem: `finding ${index}: file must be a path of 1..${FINDING_LIMITS.file} characters` };
+        const line = finding["line"];
+        if (typeof line !== "number" || !Number.isInteger(line) || line < 1)
+            return { ok: false, problem: `finding ${index}: line must be a positive whole number` };
+        const scenario = typeof finding["scenario"] === "string" ? oneLine(finding["scenario"]) : "";
+        if (scenario.length === 0 || scenario.length > FINDING_LIMITS.scenario)
+            return { ok: false, problem: `finding ${index}: scenario must be one sentence of 1..${FINDING_LIMITS.scenario} characters` };
+        findings.push({ severity, file, line, scenario });
+    }
+    return { ok: true, findings };
+}

package/dist/scope.js

@@ -2,6 +2,7 @@ import { passwordGuardOf } from "./sign-in-guard.js";
 import { validateScopeText } from "./task-text.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 import { projectAuthority } from "./project-access.js";
+import { claimActor, currentActor, parseLeadToken } from "./actor.js";
 /**
  * What a task is allowed to become, agreed before anything builds it.
  *
@@ -791,6 +792,14 @@ password) {
 export function authenticateAccount(store, by, secret) {
     if (store.listApprovers().length === 0)
         return { ok: false, reason: "no-approvers" };
+    // A lead token signs in as its owner, only inside a command the lead runs with it (never a console sign-in).
+    const acting = currentActor();
+    if (acting?.lead === true && parseLeadToken(secret) !== null) {
+        const lead = store.leadFor(secret), account = store.accountOf(by);
+        if (lead === null || lead.owner !== by || acting.account !== by || account === null)
+            return { ok: false, reason: "unknown" };
+        return { ok: true, role: account.role, generation: account.generation };
+    }
     // v99: wrong passwords in a row lock the name for a while, whatever road they came by.
     const guard = passwordGuardOf(store), now = Date.now();
     if (guard.lockedFor(by, now) > 0)
@@ -803,6 +812,8 @@ export function authenticateAccount(store, by, secret) {
     guard.succeeded(by);
     if (account.revokedAt !== null)
         return { ok: false, reason: "revoked" };
+    // Inside a command, the person who signed in is who acted (their own acts never ping them).
+    claimActor(by);
     return { ok: true, role: account.role, generation: account.generation };
 }
 /**

package/dist/serve.d.ts

@@ -1,4 +1,6 @@
+import { type BrowserWorkspace, type BrowserSignIn, type BrowserUpdateNotice } from './browser-workspace.js';
 import { CodingWorkspace } from './coding-workspace.js';
+import { type FetchLike } from "./flow-share.js";
 import { type MailSender } from "./flow-actions.js";
 import { type TriggerIo } from "./flow-triggers.js";
 import { type AssignmentSnapshot } from './assignment.js';
@@ -6,14 +8,17 @@ import type { PublishExec } from './publish.js';
 import { type VersionRunner } from "./model-catalog.js";
 import { type Server } from "node:http";
 import { type ProofVerdict, type CriterionMatrixRow } from "./proof.js";
-import { type Run, type Store } from "./store.js";
+import { type Decision, type Run, type Store, type TaskState } from "./store.js";
 import { previewGithubRepo, cloneGithubRepo, listGithubRepos } from "./onboard.js";
 import { run as execRun } from "./exec.js";
+import { type FirstRunStep } from "./first-run.js";
+import { type Gap } from "./gaps.js";
 import { type AgentChoice } from "./agentconfig.js";
 import { type RouteProjection, type RouteOverride, type RouteStamp, type RiskLevel } from "./phase-routing.js";
 import { type Phase } from "./provider.js";
 import { type IntegrationIo } from "./integrations.js";
 import { launchRuntimeUpdate } from "./toolroll-update.js";
+import type { RepairChainRow } from "./store.js";
 import type { RevisionLineage } from "./store.js";
 import type { SubscriptionMateRunner } from "./subscription-chat.js";
 import { type InstallMethod } from "./install-method.js";
@@ -39,8 +44,22 @@ export type ServeOptions = {
     registryPath?: string;
     /** This console fronts an `up` process: onboarding copy says how to watch. */
     upConsole?: boolean;
+    /**
+     * The lead on by default (onboarding): with no lead set up, the agent CLI
+     * signed in on this computer runs it, once. `up` and `serve` turn this on;
+     * tests opt in.
+     */
+    leadByDefault?: boolean;
+    /** Test seam: the operating system the sign-in command is written for. */
+    platform?: NodeJS.Platform;
     /** Extra Host values this server answers as (a Tailscale name, a LAN ip:port). */
     allowedHosts?: readonly string[];
+    /**
+     * This computer's names on its tailnet (onboarding): read at start and every
+     * few minutes; the console answers to each on its own port without an
+     * --allow-host, and the phone card names the address. Absent = none.
+     */
+    tailnetNames?: () => Promise<readonly string[]>;
     /**
      * The first-account road (setup review): while NO approver exists, the
      * login page offers "create the first account", gated by this code —
@@ -107,6 +126,8 @@ export type ServeOptions = {
     toolHome?: string;
     /** v87: sends Send email steps' mail and the settings test (tests inject one). */
     mailSender?: MailSender;
+    /** Injected by tests: how Flows → Import fetches a flow file's address. */
+    flowFetch?: FetchLike;
     /** v89: Google's token endpoint (tests inject a scripted one). */
     googleFetch?: typeof fetch;
     /** Tests: every request a one-click connection makes (discovery, registration, tokens). */
@@ -164,7 +185,14 @@ export type ServeOptions = {
     /** Injected by tests: the git and gh calls pull-request setup and Merge make. */
     publishExec?: PublishExec;
 };
-export declare function createDecisionServer(options: ServeOptions): Server;
+/** Where `up`'s one-time sign-in link points, and how long it works. */
+export declare const SIGN_IN_LINK_PATH = "/login/once/";
+export declare const SIGN_IN_LINK_MS: number;
+/** The console's server, and the one-time sign-in link `up` opens: a path on this server, or null for no such approver. */
+export type DecisionServer = Server & {
+    mintSignInLink(account: string): string | null;
+};
+export declare function createDecisionServer(options: ServeOptions): DecisionServer;
 /**
  * A vscode://file href, or null (arc 6, finding 2): the link exists only
  * when every part is provably tame — an absolute, control-free worktree;
@@ -211,6 +239,79 @@ export type RouteView = {
 };
 /** The page CSS this module writes itself (not the imported modules'), for the stylesheet contract tests. */
 export declare const PAGE_CSS: string;
+/** Everything the sidebar needs to draw itself for one request. */
+type Chrome = {
+    projectScoped?: boolean;
+    active: "code" | "inbox" | "board" | "queue" | "fleet" | "workbench" | "work" | "done" | "activity" | "review" | "system" | "tasks" | "runs" | "caps" | "routines" | "recipes" | "projects" | "flows" | "settings" | "chat" | "people" | "ledger" | "spend" | "mode" | "menu" | "none";
+    project: string | null;
+    /** The surface's scope for the scope bar — which rows this screen can
+     * show. Derived from the ROUTE, not the session: portfolio and fleet are
+     * all-project even while a project is open; the board says which of its
+     * two modes it is in. Absent = the session default (open project, else
+     * all projects). Display only — switching stays POST + CSRF. */
+    scope?: "all" | "project" | "board-all";
+    /** The saturated inbox count — never a sum of unbounded list reads. */
+    inboxCount: number;
+    inboxSaturated: boolean;
+    settings: boolean;
+    /** This database is a demo sandbox: banner every page, spend fenced. */
+    demo?: boolean;
+    /** The active operating mode's banner (M1): rides every page scoped to
+     * a repo with a live mode — a signed posture is never invisible. */
+    modeBanner?: {
+        words: string;
+        name: string;
+    };
+    /** Providers whose sign-in stopped working: every page says so, once. */
+    signIn?: BrowserSignIn[];
+    /** A newer Toolroll: a quiet notice for an operator until they dismiss this version. */
+    update?: BrowserUpdateNotice;
+    /** The chat tab renders only where chat could ever be allowed. */
+    chat?: boolean;
+    code?: boolean;
+    /** A rendered list pane makes the page master-detail. */
+    listPane?: string;
+    /** A compact pulse for the currently open workspace. Null in the
+     * cross-workspace view; absent only when the store could not answer. */
+    projectPeek?: ProjectPeek | null;
+    /** The switcher (board pass): every enrolled project inside the ceiling,
+     * most recently opened first — the one-tap switch on any screen. */
+    projects?: {
+        path: string;
+        name: string;
+    }[];
+    /** The session's csrf token, for the switcher's forms; "" when the
+     * request has no cookie session (bearer), which renders the switcher
+     * inert. */
+    csrf?: string;
+    /** Where a switch made on this screen returns to. */
+    returnTo?: string;
+};
+/**
+ * A page described, not yet rendered (arc 4): every chromed HTML route
+ * returns one of these and ONE helper (sendScreen, inside the server)
+ * owns the nonce, the palette index, the shortcuts overlay, script
+ * composition, and the CSP. Renderers stopped calling shell() themselves
+ * so those five things cannot drift apart per route.
+ */
+type Screen = {
+    title: string;
+    body: string;
+    chrome?: Chrome;
+    /** The page's own executable behavior (a region poller, the push
+     * enrollment script). fetches: true when it calls fetch — connect-src
+     * is granted only then. */
+    functional?: {
+        script: string;
+        fetches?: boolean;
+    };
+    refreshSeconds?: number;
+    /** Render sensitive even when no password field is visible — one-time
+     * secrets and judgment calls the classifier cannot see. */
+    forceSensitive?: boolean;
+    /** Structured conversation; complex guarded forms stay native islands. */
+    workspace?: Partial<Pick<BrowserWorkspace, 'conversation' | 'team' | 'focus' | 'result' | 'catchUpHtml' | 'controlsHtml' | 'notices' | 'pageHtml' | 'view' | 'firstRun' | 'phone' | 'home'>>;
+};
 /**
  * The sensitivity classifier (arc 4, findings 3/17): a body showing a
  * password input renders WITHOUT the chrome additions (palette, overlay,
@@ -232,6 +333,105 @@ export declare function ssoStepUps(html: string, sso: {
     label: string;
     fresh: boolean;
 }, returnTo: string): string;
+/**
+ * The page for an address the console doesn't answer to (onboarding): what was opened, where it answers, and the exact
+ * command that admits this address. It stands alone (styles inline, no script, no font), because every other asset
+ * would be refused at this address too; and it holds nothing a stranger's page doesn't already know.
+ */
+export declare function wrongHostPage(facts: {
+    opened: string | null;
+    served: string;
+    command: string | null;
+}): string;
+/**
+ * The inbox (v3): only things stalling progress without a person, one card
+ * per underlying stall, each with its verb inline or one step away. No
+ * auto-refresh — approval links lead to the step-up screen, and a page
+ * that might hold typed input never re-renders itself.
+ */
+export type InboxTab = "needs-you" | "ready" | "running" | "all";
+export declare function parseInboxTab(raw: string | null): InboxTab | undefined;
+/** What each tab holds, as a short fingerprint: a tab is unread when its
+ * fingerprint differs from the one this browser saw there last. */
+export declare function inboxFingerprints(data: Pick<Parameters<typeof inboxPage>[1], "decisions" | "approvals" | "requeueables" | "cancelledBlockers" | "gaps" | "needsVerification" | "ready" | "running">): Record<InboxTab, string>;
+declare function inboxPage(chrome: Chrome, data: {
+    csrf: string;
+    revision: number;
+    /** No project open in scoped mode: every admitted project at once,
+     * chips on every row, links only — acting means opening the project. */
+    rollup: boolean;
+    /** A project is OPEN: only then do decisions answer on the card. The
+     * legacy unscoped projectless inbox stays links-only too (commit-1
+     * review, finding 4) — the partial belongs to a chosen project. */
+    interactive: boolean;
+    decisions: (Decision & {
+        taskId: string;
+        repo?: string | null;
+    })[];
+    approvals: {
+        taskId: string;
+        title: string;
+        goal: string;
+        proposedAt: string;
+        repo?: string | null; /** v48 authority repair: the closed consent door's title, or null when a yes could bind. */
+        closed?: string | null;
+    }[];
+    requeueables: {
+        taskId: string;
+        title: string;
+        state: TaskState;
+        strikes: number;
+        incidentCount: number;
+        repo?: string | null;
+    }[];
+    cancelledBlockers: {
+        blockerId: string;
+        dependentCount: number;
+        exampleDependent: string;
+        repo?: string | null;
+        blockerRepo?: string | null;
+    }[];
+    gaps: Gap[];
+    /** A completed task whose proof is short or refuted and not yet accepted
+     * (Priority 2) — reads "needs verification" here too, never silently
+     * "done" just because the inbox does not otherwise look at finished work. */
+    needsVerification: {
+        taskId: string;
+        title: string;
+        verdict: "short" | "refuted";
+        repo?: string | null;
+        matrix?: CriterionMatrixRow[];
+        repairChain?: RepairChainRow | null;
+    }[];
+    /** The first-run steps; null once the installation has had its first Ready result. */
+    wizard: FirstRunStep[] | null;
+    /** Whether any worker is answering right now — said at the top when none is. */
+    worker: {
+        answering: number;
+        registered: number;
+        lastHeard: string | null;
+    };
+    now: Date;
+    /** Console v2: the tab shown, results ready to review, work running now,
+     * and the tabs holding something this browser hasn't seen (dots on a phone). */
+    tab?: InboxTab;
+    ready?: {
+        taskId: string;
+        title: string;
+        detail: string;
+        repo: string | null;
+    }[];
+    running?: {
+        taskId: string;
+        title: string;
+        detail: string;
+        repo: string | null;
+    }[];
+    unread?: readonly InboxTab[];
+}): Screen;
+/** The task composer's modes (console v2), as the words the lead reads for that one turn. */
+export type TaskComposerMode = "build" | "plan" | "answer";
+export declare const TASK_COMPOSER_MODES: Record<TaskComposerMode, string>;
 /**
  * The inline-answer enhancement (portfolio arc §2): submits a reversible
  * option's form as the urlencoded POST the forms-only gate expects, follows
@@ -242,6 +442,12 @@ export declare function ssoStepUps(html: string, sso: {
  * Nothing else on the page is touched: typed input elsewhere survives.
  */
 export declare function decisionAnswerScript(): string;
+type ProjectPeek = {
+    waiting: number;
+    queued: number;
+    running: number;
+    doneRecently: number;
+};
 /**
  * Creating work is the product's first verb, so it gets a whole calm page:
  * a title, the goal that becomes the scope draft, and the project it lands
@@ -257,6 +463,8 @@ export declare function decisionAnswerScript(): string;
  */
 /** The person's pinned theme from their own cookie; null follows the device. */
 export declare function pinnedTheme(cookieHeader: string | undefined): "light" | "dark" | null;
+/** A request path fit for a log: the one-time sign-in link's code is left out. */
+export declare function redactedPath(path: string): string;
 /** The /queue page's one nonce'd script: delegated pointer-event drag (it
  * survives every fragment swap — finding 17) plus a poller that re-checks
  * focus, dirty inputs, and an in-flight drag AT SWAP TIME, never only
@@ -339,3 +547,4 @@ export declare function plainConclusionOf(conclusion: string): string;
  * stop marker, so an open tab quits refetching a dead build (round-4
  * finding 15). */
 export declare function runFactsFragment(run: Run, taskId: string, live: boolean, route?: RouteStamp | null): string;
+export {};