toolroll 0.9.24 → 0.9.26

package/dist/desktop-update.d.ts

@@ -125,6 +125,7 @@ export declare function prepareDesktopUpdate(stateDir: string, installed: string
 export declare function sqliteLock(file: string, busyTimeoutMs?: number): DatabaseSync | null;
 export declare const installationLock: (j: UpdateJournal) => DatabaseSync | null;
 export declare function desktopUpdateStatus(stateDir: string): {
+    version?: never;
     active: boolean;
     phase: string;
     detail: string;
@@ -138,7 +139,6 @@ export declare function desktopUpdateStatus(stateDir: string): {
     wasRunning?: never;
     backupPath?: never;
     updateId?: never;
-    version?: never;
     buildId?: never;
     workDir?: never;
 } | {

package/dist/flow-cadence.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Flow passes that don't wait for builds. The worker's pass used to move
+ * cards only between builds, so a card whose research finished sat still
+ * while another build ran (Oct 4: five minutes). Now the worker runs these
+ * passes on their own cadence beside its builds, and a finished build,
+ * research or check moves its card at once.
+ *
+ * Model-free and cheap: nothing here starts a build. Cards entering a build
+ * zone file their task, which waits for a free slot like any other.
+ */
+import { type FlowAdvance } from "./flow-engine.js";
+import { type TriggerIo, type TriggerPass } from "./flow-triggers.js";
+import { type ReplyWatch, type ReplyWatchIo } from "./flow-replies.js";
+import { type StepIo, type StepPass } from "./flow-steps.js";
+import type { Store } from "./store.js";
+/** How often the worker moves cards, checks triggers, reads replies and runs steps, builds or not. */
+export declare const FLOW_EVERY_MS = 15000;
+/** One pass of a kind for a project at a time in this process: a second one asked for while it runs is skipped
+ * (`idle`), and the next cadence takes up whatever it would have done. Cards are also claimed in the database,
+ * so passes in other processes can't act twice either. */
+export declare function alone<T>(kind: string, project: string, idle: T, run: () => Promise<T>): Promise<T>;
+export type FlowIo = {
+    triggers: TriggerIo;
+    replies: ReplyWatchIo;
+    steps: StepIo;
+    evidenceRoot?: string;
+};
+export type FlowHousekeeping = {
+    triggers: TriggerPass;
+    replies: ReplyWatch;
+    steps: StepPass;
+    flows: FlowAdvance;
+};
+/** One project's flow pass: triggers (which may start cards), replies (which move waiting cards), steps, then moves.
+ * `halted` (a stop or paused admission) skips everything that reaches outside; moves still run. */
+export declare function flowHousekeeping(store: Store, repo: string, clock: () => Date, io: FlowIo, halted: () => boolean): Promise<FlowHousekeeping>;
+/** Move one project's cards. Synchronous, so two can't overlap in a process; each move is checked against the
+ * card's visit in its own transaction, so a pass in another process can't move a card twice. */
+export declare function moveCards(store: Store, repo: string, now: Date, evidenceRoot: string | undefined): FlowAdvance;
+/** A build, research or check just finished: move the cards in this project, and in the project of any flow whose
+ * card that task belongs to (a build zone may build in another project), now rather than on the next pass. */
+export declare function moveCardsAfter(store: Store, repo: string, tasks: readonly string[], now: Date, evidenceRoot: string | undefined): FlowAdvance;

package/dist/flow-cadence.js

@@ -0,0 +1,78 @@
+/**
+ * Flow passes that don't wait for builds. The worker's pass used to move
+ * cards only between builds, so a card whose research finished sat still
+ * while another build ran (Oct 4: five minutes). Now the worker runs these
+ * passes on their own cadence beside its builds, and a finished build,
+ * research or check moves its card at once.
+ *
+ * Model-free and cheap: nothing here starts a build. Cards entering a build
+ * zone file their task, which waits for a free slot like any other.
+ */
+import { advanceFlows } from "./flow-engine.js";
+import { runFlowTriggers } from "./flow-triggers.js";
+import { watchFlowReplies } from "./flow-replies.js";
+import { runFlowSteps } from "./flow-steps.js";
+/** How often the worker moves cards, checks triggers, reads replies and runs steps, builds or not. */
+export const FLOW_EVERY_MS = 15_000;
+const running = new Set();
+/** One pass of a kind for a project at a time in this process: a second one asked for while it runs is skipped
+ * (`idle`), and the next cadence takes up whatever it would have done. Cards are also claimed in the database,
+ * so passes in other processes can't act twice either. */
+export async function alone(kind, project, idle, run) {
+    const key = `${kind}\u0000${project}`;
+    if (running.has(key))
+        return idle;
+    running.add(key);
+    try {
+        return await run();
+    }
+    finally {
+        running.delete(key);
+    }
+}
+/** One project's flow pass: triggers (which may start cards), replies (which move waiting cards), steps, then moves.
+ * `halted` (a stop or paused admission) skips everything that reaches outside; moves still run. */
+export async function flowHousekeeping(store, repo, clock, io, halted) {
+    const triggers = halted() ? { added: 0, checked: 0, problems: [] }
+        : await alone("triggers", repo, { added: 0, checked: 0, problems: [] }, () => runFlowTriggers(store, repo, clock(), io.triggers));
+    // One mailbox serves every project, so its reads are one at a time across them all.
+    const replies = halted() ? { read: 0, taken: 0, problem: null }
+        : await alone("replies", "*", { read: 0, taken: 0, problem: null }, () => watchFlowReplies(store, clock(), io.replies));
+    const steps = halted() ? { ran: 0, problems: [] }
+        : await alone("steps", repo, { ran: 0, problems: [] }, () => runFlowSteps(store, repo, clock(), io.steps));
+    // Last, so a step that just finished, or a card a trigger just added, moves now.
+    const flows = moveCards(store, repo, clock(), io.evidenceRoot);
+    return { triggers, replies, steps, flows };
+}
+/** Move one project's cards. Synchronous, so two can't overlap in a process; each move is checked against the
+ * card's visit in its own transaction, so a pass in another process can't move a card twice. */
+export function moveCards(store, repo, now, evidenceRoot) {
+    try {
+        return advanceFlows(store, repo, now, evidenceRoot === undefined ? {} : { evidenceRoot });
+    }
+    catch (error) {
+        return { moved: 0, filed: [], problems: [`flows: ${error instanceof Error ? error.message : "could not move cards"}`] };
+    }
+}
+/** A build, research or check just finished: move the cards in this project, and in the project of any flow whose
+ * card that task belongs to (a build zone may build in another project), now rather than on the next pass. */
+export function moveCardsAfter(store, repo, tasks, now, evidenceRoot) {
+    const projects = new Set([repo]);
+    for (const task of tasks) {
+        try {
+            const card = store.flowCardByTask(task) ?? store.flowCardByTask(store.taskFamilyOf(task, null, true)?.root.id ?? task);
+            const flow = card === null ? null : store.getFlow(card.flow);
+            if (flow !== null)
+                projects.add(flow.repo);
+        }
+        catch { /* not a task with a card */ }
+    }
+    const outcome = { moved: 0, filed: [], problems: [] };
+    for (const project of projects) {
+        const moved = moveCards(store, project, now, evidenceRoot);
+        outcome.moved += moved.moved;
+        outcome.filed.push(...moved.filed);
+        outcome.problems.push(...moved.problems);
+    }
+    return outcome;
+}

package/dist/invoke.d.ts

@@ -103,6 +103,9 @@ export declare function invokeAgent(store: Store, runId: number, spec: AgentSpec
  * hold belongs to the coordinator, never to a promise chain that would
  * stall the watch.
  */
+/** What a held session may use of the project's tools: a research run, which may only read and isn't told here which
+ * actions are read-only, gets none at all; any other run gets them as launched. */
+export declare function heldReadOnly(store: Store, runId: number): Readonly<Record<string, readonly string[]>> | undefined;
 export declare function invokeHeldAgent(store: Store, runId: number, spec: AgentSpec, argv: readonly string[], options: import("./exec.js").RunOptions & {
     socketPath: string;
     cookie: string;

package/dist/invoke.js

@@ -292,7 +292,7 @@ export async function invokeAgent(store, runId, spec, invocation, options) {
     const isolatedDb = isolatedAgentDatabase(runId);
     // The project's tools (v80): exactly its MCP servers, and none of the
     // operator's global or a repository's own. A review keeps its isolation.
-    const tools = invocation.phase === "review" ? null : runTools(store, runId, spec, options.keyHome, clock);
+    const tools = invocation.phase === "review" ? null : runTools(store, runId, spec, options.keyHome, clock, invocation.readOnlyTools);
     // The agent fence: Toolroll's own secrets, database and other runs'
     // evidence stay out of reach, whatever the permission mode. A review is
     // already confined to its sealed files.
@@ -583,6 +583,11 @@ export async function invokeAgent(store, runId, spec, invocation, options) {
  * hold belongs to the coordinator, never to a promise chain that would
  * stall the watch.
  */
+/** What a held session may use of the project's tools: a research run, which may only read and isn't told here which
+ * actions are read-only, gets none at all; any other run gets them as launched. */
+export function heldReadOnly(store, runId) {
+    return store.getRun(runId)?.role === "scout" ? {} : undefined;
+}
 export async function invokeHeldAgent(store, runId, spec, argv, options) {
     const clock = options.clock ?? (() => new Date());
     const run = store.getRun(runId);
@@ -624,7 +629,7 @@ export async function invokeHeldAgent(store, runId, spec, argv, options) {
     const isolatedDb = isolatedAgentDatabase(runId);
     // The project's tools (v80), as for every build: exactly its MCP servers;
     // and the agent fence around Toolroll's own secrets.
-    const heldTools = runTools(store, runId, spec, keyHome, clock);
+    const heldTools = runTools(store, runId, spec, keyHome, clock, heldReadOnly(store, runId));
     const heldFence = runFence(store, runId, keyHome);
     argv = [...argv, ...heldTools.argv, ...(heldFence.length > 0 ? ["--settings", claudeFenceSettings(heldFence)] : [])];
     const heldLaunch = fenceLaunch("claude", heldFence);
@@ -786,9 +791,9 @@ function fenceLaunch(provider, fence) {
     return { wrap: [], method: provider === "claude" ? "claude-rules" : "none" };
 }
 /** One launch's tools, or — when they cannot be prepared — the same isolation with none, never the operator's global servers. */
-function runTools(store, runId, spec, keyHome, clock) {
+function runTools(store, runId, spec, keyHome, clock, readOnly) {
     try {
-        return prepareRunTools(store, runId, spec.provider, { ...(keyHome === undefined ? {} : { home: keyHome }), now: clock(), includeModel: spec.model === null });
+        return prepareRunTools(store, runId, spec.provider, { ...(keyHome === undefined ? {} : { home: keyHome }), now: clock(), includeModel: spec.model === null, ...(readOnly === undefined ? {} : { readOnly }) });
     }
     catch {
         return noToolsArgs(spec.provider, spec.model === null);

package/dist/mate-tools.js

@@ -761,7 +761,7 @@ export const MATE_TOOLS = [
     },
     {
         name: "get_project_tools",
-        description: "Read a project's tools (the MCP servers its builds get, and only those), the services that connect by signing in, the common tools list and servers found on this computer. A service in connectBySigningIn (Stripe, Notion, Linear, Sentry, Jira…) connects in one click: the person signs in on the service's own page, so give them its connect link and never propose tool_add for it. Add/remove others with propose_action tool_add/tool_remove; secrets are set only on the Tools page.",
+        description: "Read a project's tools (the MCP servers its builds get, and only those), the services that connect by signing in, the common tools list and servers found on this computer. A service in connectBySigningIn (Stripe, Notion, Linear, Sentry, Jira…) connects in one click: the person signs in on the service's own page, so give them its connect link (for this repo; another project has its own) and never propose tool_add for it. When saying a service is connected, name the project it is connected to (its list_repos name). Add/remove others with propose_action tool_add/tool_remove; secrets are set only on the Tools page.",
         inputSchema: schema({ repo: REPO_ARG }, ["repo"]),
         handle: (ctx, args) => {
             const repo = repoPathOf(ctx.who, args["repo"]);

package/dist/mcp-connect.d.ts

@@ -1,12 +1,29 @@
-import { type ToolSpec } from "./project-tools.js";
+import { type ProjectTool, type ToolSpec } from "./project-tools.js";
 import type { Store } from "./store.js";
-/** Services verified to connect this way (their servers speak streamable HTTP and register clients on the spot). */
-export declare const ONE_CLICK: readonly {
+/**
+ * A one-click service. `reads` names what a research step may read there:
+ * an action is read-only only when it is named by a reading verb (READING)
+ * and every other word in its name is one of these.
+ */
+export type OneClick = {
     id: string;
     label: string;
     url: string;
     about: string;
-}[];
+    reads?: readonly string[];
+};
+/**
+ * Services that connect this way: their servers speak streamable HTTP and
+ * advertise registering clients on the spot. Advertising isn't accepting:
+ * Figma's server advertises it, but its registration answers 403 to any app
+ * Figma hasn't approved, so Figma connects through its desktop app instead
+ * (LOCAL_APPS). A service is listed only when its registration accepts
+ * Toolroll; mcp-connect.test.ts replays each one's answer (no live calls).
+ *
+ * Signed in end to end, live: Mobbin. The rest register in replayed checks
+ * only, until someone signs in to each for real.
+ */
+export declare const ONE_CLICK: readonly OneClick[];
 /**
  * The list, with one service standing in on this computer when the person
  * running Toolroll says so ("stripe|Stripe|http://127.0.0.1:5123/mcp"
@@ -14,19 +31,45 @@ export declare const ONE_CLICK: readonly {
  * real without a real account. Only a loopback address is taken.
  */
 export declare function oneClickServices(environment?: NodeJS.ProcessEnv): typeof ONE_CLICK;
-export declare const oneClickOf: (id: string) => {
+export declare const oneClickOf: (id: string) => OneClick | null;
+/** An app on this computer that Connect adds without a sign-in (LOCAL_APPS): its tool, name and one line of how. */
+export declare const localConnectOf: (id: string) => {
     id: string;
     label: string;
-    url: string;
     about: string;
 } | null;
-/** Where each service stands in a project: connected by signing in, open to connect, or its name taken by a tool set up another way. */
+/** Where each service stands in a project: connected, open to connect, or its name taken by a tool set up another way. `local` connects with no sign-in. */
 export declare function connectionsOf(store: Store, repo: string): {
     id: string;
     label: string;
     about: string;
     state: "connected" | "open" | "taken";
+    local?: true;
 }[];
+/**
+ * Whether an action only reads: its name has a reading verb, and every other
+ * word is a reading verb, a qualifier or something this service lets
+ * research read. An allow-list: a word nobody listed withholds the action.
+ */
+export declare function readsOnly(action: string, subjects: readonly string[]): boolean;
+/**
+ * What a research step may use of a project's connected services: each
+ * signed-in service's read-only actions, as its last test listed them —
+ * by server (`reads`, for Codex's `enabled_tools`) and named the way Claude
+ * allows them (`mcp__<service>__<action>`). `local` is the loopback host of
+ * each app on this computer it reads (its proxy lets only those through). A service not connected, without
+ * read-only actions, or left out of this run (`launched`) gives nothing.
+ */
+export type ResearchTools = {
+    services: {
+        id: string;
+        label: string;
+    }[];
+    allowed: string[];
+    reads: Record<string, string[]>;
+    local: string[];
+};
+export declare function researchToolsOf(tools: readonly ProjectTool[], launched?: ReadonlySet<string> | null): ResearchTools;
 /** Where a service sends the person back after they sign in. */
 export declare const CONNECT_CALLBACK = "/settings/tools/connected";
 type Fetch = typeof fetch;

package/dist/mcp-connect.js

@@ -13,9 +13,20 @@
  */
 import { createHash, randomBytes } from "node:crypto";
 import { homedir } from "node:os";
-import { addToolTo, projectToolsOf, readToolSecrets, setToolSecrets, testToolOf } from "./project-tools.js";
+import { basename } from "node:path";
+import { LOCAL_APPS, addToolTo, catalogTool, localAppOf, projectToolsOf, readToolSecrets, setToolSecrets, testToolOf } from "./project-tools.js";
 import { envValue } from "./names.js";
-/** Services verified to connect this way (their servers speak streamable HTTP and register clients on the spot). */
+/**
+ * Services that connect this way: their servers speak streamable HTTP and
+ * advertise registering clients on the spot. Advertising isn't accepting:
+ * Figma's server advertises it, but its registration answers 403 to any app
+ * Figma hasn't approved, so Figma connects through its desktop app instead
+ * (LOCAL_APPS). A service is listed only when its registration accepts
+ * Toolroll; mcp-connect.test.ts replays each one's answer (no live calls).
+ *
+ * Signed in end to end, live: Mobbin. The rest register in replayed checks
+ * only, until someone signs in to each for real.
+ */
 export const ONE_CLICK = [
     { id: "stripe", label: "Stripe", url: "https://mcp.stripe.com/", about: "Payments, customers, refunds and invoices." },
     { id: "notion", label: "Notion", url: "https://mcp.notion.com/mcp", about: "Pages and databases: search, read and write." },
@@ -33,6 +44,13 @@ export const ONE_CLICK = [
     { id: "canva", label: "Canva", url: "https://mcp.canva.com/mcp", about: "Designs: search, create and export." },
     { id: "vercel", label: "Vercel", url: "https://mcp.vercel.com/", about: "Projects, deployments and logs." },
     { id: "cloudflare", label: "Cloudflare", url: "https://mcp.cloudflare.com/mcp", about: "Workers, DNS and your Cloudflare account." },
+    // Mobbin's sign-in is its Supabase auth server, on another origin: its protected-resource metadata names it.
+    { id: "mobbin", label: "Mobbin", url: "https://api.mobbin.com/mcp", about: "Real app screens and flows to learn from.",
+        reads: ["screen", "flow", "app", "site", "element", "pattern", "ui", "ios", "android", "web"] },
+    { id: "posthog", label: "PostHog", url: "https://mcp.posthog.com/mcp", about: "Product analytics, funnels and events.",
+        reads: ["insight", "run", "event", "definition", "property", "properties"] },
+    { id: "betterstack", label: "Better Stack", url: "https://mcp.betterstack.com", about: "Uptime checks and incidents.",
+        reads: ["uptime", "monitor", "incident", "availability", "response", "time"] },
 ];
 const loopback = (value) => { try {
     const url = new URL(value);
@@ -51,17 +69,72 @@ export function oneClickServices(environment = process.env) {
     const [id = "", label = "", url = ""] = (envValue(environment, "TEST_CONNECT") ?? "").split("|");
     if (!/^[a-z0-9-]{1,40}$/.test(id) || label === "" || !loopback(url))
         return ONE_CLICK;
-    const standIn = { id, label, url, about: ONE_CLICK.find(one => one.id === id)?.about ?? "A service on this computer." };
+    const known = ONE_CLICK.find(one => one.id === id);
+    const standIn = { id, label, url, about: known?.about ?? "A service on this computer.", ...(known?.reads === undefined ? {} : { reads: known.reads }) };
     return ONE_CLICK.some(one => one.id === id) ? ONE_CLICK.map(one => one.id === id ? standIn : one) : [...ONE_CLICK, standIn];
 }
 export const oneClickOf = (id) => oneClickServices().find(one => one.id === id) ?? null;
-/** Where each service stands in a project: connected by signing in, open to connect, or its name taken by a tool set up another way. */
+/** What to use when a service won't let Toolroll sign in by itself. */
+const INSTEAD = { figma: "Connect Figma (desktop app) instead." };
+/** An app on this computer that Connect adds without a sign-in (LOCAL_APPS): its tool, name and one line of how. */
+export const localConnectOf = (id) => {
+    const app = LOCAL_APPS.find(one => one.tool === id), tool = catalogTool(id);
+    return app === undefined || tool === null ? null : { id, label: tool.label, about: app.connect };
+};
+/** Where each service stands in a project: connected, open to connect, or its name taken by a tool set up another way. `local` connects with no sign-in. */
 export function connectionsOf(store, repo) {
     const tools = projectToolsOf(store, repo);
-    return oneClickServices().map(service => {
+    const signIn = oneClickServices().map(service => {
         const had = tools.find(one => one.name === service.id);
         return { id: service.id, label: service.label, about: service.about, state: had === undefined ? "open" : had.spec.url === service.url && had.spec.bearer === ACCESS ? "connected" : "taken" };
     });
+    const local = LOCAL_APPS.flatMap(app => {
+        const one = localConnectOf(app.tool);
+        if (one === null)
+            return [];
+        const had = tools.find(tool => tool.name === one.id);
+        return [{ ...one, state: had === undefined ? "open" : localAppOf(had.spec) !== null ? "connected" : "taken", local: true }];
+    });
+    return [...signIn, ...local];
+}
+/** The verbs that only read. An action named by anything else is withheld from research. */
+const READING = new Set(["list", "get", "search", "find", "read", "query", "describe", "fetch", "view", "export-image"]);
+/** Words that only qualify what is read ("insights-get-all", "get_by_id"). */
+const QUALIFIERS = new Set(["all", "by", "id", "ids"]);
+/**
+ * Whether an action only reads: its name has a reading verb, and every other
+ * word is a reading verb, a qualifier or something this service lets
+ * research read. An allow-list: a word nobody listed withholds the action.
+ */
+export function readsOnly(action, subjects) {
+    if (!/^[A-Za-z0-9_.-]{1,64}$/.test(action))
+        return false;
+    const words = action.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase().split(/[^a-z0-9]+/).filter(word => word !== "")
+        .join(" ").replace(/\bexport images?\b/g, "export-image").split(" ");
+    const subject = (word) => subjects.includes(word) || subjects.includes(word.replace(/s$/, ""));
+    return words.some(word => READING.has(word)) && words.every(word => READING.has(word) || QUALIFIERS.has(word) || subject(word));
+}
+export function researchToolsOf(tools, launched = null) {
+    const research = { services: [], allowed: [], reads: {}, local: [] };
+    // Signed-in services, then apps on this computer (each exactly as listed: its own address, no key).
+    const readable = [
+        ...oneClickServices().map(service => ({ id: service.id, label: service.label, reads: service.reads, is: (spec) => spec.url === service.url && spec.bearer === ACCESS })),
+        ...LOCAL_APPS.map(app => ({ id: app.tool, label: catalogTool(app.tool)?.label ?? app.tool, reads: app.reads, is: (spec) => localAppOf(spec) === app })),
+    ];
+    for (const service of readable) {
+        const tool = tools.find(one => one.name === service.id);
+        if (service.reads === undefined || tool === undefined || !service.is(tool.spec) || (launched !== null && !launched.has(tool.name)))
+            continue;
+        const reads = (tool.lastTest?.ok ? tool.lastTest.tools : []).filter(action => readsOnly(action, service.reads));
+        if (reads.length === 0)
+            continue;
+        research.services.push({ id: service.id, label: service.label });
+        research.allowed.push(...reads.map(action => `mcp__${service.id}__${action}`));
+        research.reads[service.id] = reads;
+        if (localAppOf(tool.spec) !== null)
+            research.local.push(new URL(tool.spec.url).host);
+    }
+    return research;
 }
 /** The secrets a connected tool keeps: the bearer the MCP server takes, and what refreshing it needs. */
 const ACCESS = "OAUTH_ACCESS_TOKEN", REFRESH = "OAUTH_REFRESH_TOKEN", CLIENT = "OAUTH_CLIENT_ID", CLIENT_SECRET = "OAUTH_CLIENT_SECRET", TOKEN_URL = "OAUTH_TOKEN_URL", EXPIRES = "OAUTH_EXPIRES_AT", RESOURCE = "OAUTH_RESOURCE";
@@ -110,6 +183,7 @@ export async function discoverSignIn(mcpUrl, fetcher = fetch) {
     const path = issuer.pathname === "/" ? "" : issuer.pathname.replace(/\/$/, "");
     const meta = await json(fetcher, `${issuer.origin}/.well-known/oauth-authorization-server${path}`)
         ?? await json(fetcher, `${issuer.origin}/.well-known/oauth-authorization-server`)
+        ?? (path === "" ? null : await json(fetcher, `${issuer.origin}${path}/.well-known/openid-configuration`))
         ?? await json(fetcher, `${issuer.origin}/.well-known/openid-configuration`);
     if (meta === null || !https(meta["authorization_endpoint"]) || !https(meta["token_endpoint"]) || !https(meta["registration_endpoint"]))
         return null;
@@ -138,6 +212,9 @@ export async function startConnect(input, fetcher = fetch, now = Date.now()) {
     try {
         const registered = await fetcher(server.register, { method: "POST", headers: { "content-type": "application/json", accept: "application/json" }, signal: AbortSignal.timeout(10_000),
             body: JSON.stringify({ client_name: "Toolroll", redirect_uris: [redirect], grant_types: ["authorization_code", "refresh_token"], response_types: ["code"], token_endpoint_auth_method: "none" }) });
+        // Figma's answer (Oct 2026): it registers only apps it has approved. Said before reading a body that may not be JSON.
+        if (registered.status === 401 || registered.status === 403)
+            return { ok: false, said: `${service.label} doesn't let other apps sign in this way yet.${INSTEAD[service.id] === undefined ? "" : ` ${INSTEAD[service.id]}`}` };
         const body = await registered.json();
         if (!registered.ok || typeof body.client_id !== "string")
             return { ok: false, said: `${service.label} didn't let Toolroll register (HTTP ${registered.status}).` };
@@ -208,11 +285,13 @@ export async function finishConnect(store, visit, code, now, options = {}) {
     }
     setToolSecrets(visit.repo, spec.name, { [ACCESS]: tokens.access, [CLIENT]: visit.clientId, [TOKEN_URL]: visit.token, [RESOURCE]: visit.resource,
         ...(tokens.refresh === null ? {} : { [REFRESH]: tokens.refresh }), ...(tokens.expires === null ? {} : { [EXPIRES]: tokens.expires }), ...(visit.clientSecret === null ? {} : { [CLIENT_SECRET]: visit.clientSecret }) }, home);
+    // The success line names the project it went to: the page and chat may be looking at another.
+    const to = basename(visit.repo);
     if (options.test === false)
-        return { ok: true, said: `${service.label} is connected.` };
+        return { ok: true, said: `${service.label} is connected to ${to}.` };
     const tested = await testToolOf(store, visit.repo, spec.name, now, { home, ...(options.omitEnv === undefined ? {} : { omitEnv: options.omitEnv }) });
-    return tested?.ok ? { ok: true, said: `${service.label} is connected: ${tested.tools.length} action${tested.tools.length === 1 ? "" : "s"}. Let a teammate use it from its page.` }
-        : { ok: true, said: `${service.label} is signed in, but its test didn't pass yet: ${tested?.problem ?? "no answer"}.` };
+    return tested?.ok ? { ok: true, said: `${service.label} is connected to ${to}: ${tested.tools.length} action${tested.tools.length === 1 ? "" : "s"}. Let a teammate use it from its page.` }
+        : { ok: true, said: `${service.label} is signed in for ${to}, but its test didn't pass yet: ${tested?.problem ?? "no answer"}.` };
 }
 /** Keep connected services signed in: any token expiring within ten minutes is refreshed (the worker's pass, and before a teammate's call). */
 export async function refreshConnections(store, repos, now, options = {}) {

package/dist/operate.d.ts

@@ -1,7 +1,7 @@
 import { type IntegrationIo } from "./integrations.js";
 import { type OnboardIo } from "./agent-onboard.js";
 import { type TriggerIo } from "./flow-triggers.js";
-import { type StepIo } from "./flow-steps.js";
+import type { StepIo } from "./flow-steps.js";
 import type { FetchLike } from "./flow-share.js";
 import { type Store } from "./store.js";
 import { type DispatchAdapter } from "./sync.js";
@@ -61,6 +61,8 @@ export type OperateOptions = {
     flowTriggerIo?: Partial<TriggerIo>;
     /** Injected by tests: how flow check and update steps run commands and reach GitHub and Linear. */
     flowStepIo?: Partial<StepIo>;
+    /** Injected by tests: how often a worker's flow passes run beside its builds (default FLOW_EVERY_MS). */
+    flowEveryMs?: number;
     /** Injected by tests: how `flows import` fetches a flow file's address. */
     flowFetch?: FetchLike;
     /** Injected by tests: how `integrations` checks reach services (fetch, gh, sign-in checks, mail servers). */