@catalyst-cloud/cli 0.14.6 → 0.14.7

package/dist/onboard-bootstrap.js

@@ -0,0 +1,162 @@
+import { createHash } from "node:crypto";
+import { isAbsolute, normalize } from "node:path";
+import { CliError } from "./errors.js";
+function refused() {
+    throw new CliError("The staged installation plan could not be verified. Run setup again.", "onboard-bootstrap-plan", 12);
+}
+function record(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return refused();
+    return value;
+}
+function exactKeys(value, keys) {
+    if (Object.keys(value).length !== keys.length ||
+        keys.some((key) => !Object.hasOwn(value, key)))
+        refused();
+}
+function text(value) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > 4096 ||
+        /[\u0000-\u001f\u007f-\u009f\u2028\u2029]/.test(value))
+        refused();
+    return value;
+}
+function path(value) {
+    const result = text(value);
+    if (!isAbsolute(result) || normalize(result) !== result || result === "/")
+        refused();
+    return result;
+}
+function origin(value) {
+    const result = text(value);
+    let url;
+    try {
+        url = new URL(result);
+    }
+    catch {
+        return refused();
+    }
+    if (url.protocol !== "https:" ||
+        url.origin !== result ||
+        url.username ||
+        url.password ||
+        url.search ||
+        url.hash)
+        refused();
+    return result;
+}
+/** Copies a closed DTO before freezing it; a mutable caller object cannot alter the displayed plan. */
+export function parseBootstrapPlan(input) {
+    const value = record(input);
+    exactKeys(value, [
+        "schema",
+        "home",
+        "origin",
+        "platform",
+        "arch",
+        "cliPath",
+        "skillsPath",
+        "statePath",
+        "dailyUpdate",
+        "artifacts",
+    ]);
+    if (value.schema !== 1 ||
+        (value.platform !== "darwin" && value.platform !== "linux") ||
+        (value.arch !== "arm64" && value.arch !== "x64") ||
+        typeof value.dailyUpdate !== "boolean" ||
+        !Array.isArray(value.artifacts) ||
+        value.artifacts.length !== 4)
+        refused();
+    const kinds = new Set();
+    const artifacts = value.artifacts
+        .map((input) => {
+        const item = record(input);
+        exactKeys(item, ["kind", "version", "sha256"]);
+        if (item.kind !== "runtime" &&
+            item.kind !== "cli" &&
+            item.kind !== "skills" &&
+            item.kind !== "installer")
+            refused();
+        if (kinds.has(item.kind))
+            refused();
+        kinds.add(item.kind);
+        const version = text(item.version);
+        if (!/^[0-9A-Za-z][0-9A-Za-z.+_-]{0,127}$/.test(version) ||
+            typeof item.sha256 !== "string" ||
+            !/^[a-f0-9]{64}$/.test(item.sha256))
+            refused();
+        return Object.freeze({ kind: item.kind, version, sha256: item.sha256 });
+    })
+        .sort((a, b) => a.kind.localeCompare(b.kind));
+    const home = path(value.home), cliPath = path(value.cliPath), skillsPath = path(value.skillsPath), statePath = path(value.statePath);
+    if (new Set([home, cliPath, skillsPath, statePath]).size !== 4)
+        refused();
+    return Object.freeze({
+        schema: 1,
+        home,
+        origin: origin(value.origin),
+        platform: value.platform,
+        arch: value.arch,
+        cliPath,
+        skillsPath,
+        statePath,
+        dailyUpdate: value.dailyUpdate,
+        artifacts: Object.freeze(artifacts),
+    });
+}
+export function bootstrapPlanHash(plan) {
+    return createHash("sha256")
+        .update(JSON.stringify(parseBootstrapPlan(plan)))
+        .digest("hex");
+}
+export function bootstrapPlanLines(plan) {
+    return [
+        `Install on ${plan.platform}/${plan.arch} for ${plan.home}`,
+        `Catalyst cloud: ${plan.origin}`,
+        `Command: ${plan.cliPath}`,
+        `Skills: ${plan.skillsPath}`,
+        `Setup record: ${plan.statePath}`,
+        `Daily update: ${plan.dailyUpdate ? "schedule after installation" : "not selected"}`,
+        ...plan.artifacts.map((artifact) => `${artifact.kind} ${artifact.version} (SHA-256 ${artifact.sha256})`),
+    ];
+}
+/** A prepared native continuation is consumed before entering the first persistent machine stage.
+ * Retry after a partial install constructs a new preview from the actual machine and journal.
+ */
+export function createBootstrapPreview(input, ports) {
+    const plan = parseBootstrapPlan(input);
+    const planHash = bootstrapPlanHash(plan);
+    let consumed = false;
+    return Object.freeze({
+        plan,
+        async recheck() {
+            if (consumed)
+                refused();
+            await ports.recheck();
+        },
+        assertCurrent() {
+            if (consumed)
+                refused();
+            ports.assertCurrent();
+        },
+        async continue(approved, signal) {
+            if (consumed ||
+                signal.aborted ||
+                approved.planHash !== planHash ||
+                bootstrapPlanHash(approved.plan) !== planHash ||
+                approved.origin !== plan.origin ||
+                !approved.account ||
+                !approved.person ||
+                !approved.runId ||
+                !Number.isSafeInteger(approved.ownerPid) ||
+                approved.ownerPid < 1 ||
+                !approved.ownerToken ||
+                !isAbsolute(approved.lockPath))
+                refused();
+            consumed = true;
+            ports.assertCurrent();
+            await ports.continue(approved, signal);
+        },
+    });
+}

package/dist/onboard-capabilities.js

@@ -119,7 +119,7 @@ async function read(ctx, journal, timeoutMs, external) {
                         !["GET", "POST"].includes(row.method) ||
                         typeof row.path !== "string" ||
                         row.path.length > 240 ||
-                        !/^\/(?:api\/v1\/|connect\/|me\/)[A-Za-z0-9_/-]+$/.test(row.path) ||
+                        !(/^\/(?:api\/v1\/|connect\/|me\/)[A-Za-z0-9_/-]+$/.test(row.path) || row.path === "/api/v1/coding-accounts/:slot/validate") ||
                         row.personalBearer !== true)
                         return { reason: "onboarding_capability_unavailable", origin };
                     const key = `${row.method} ${row.path}`;
@@ -142,6 +142,17 @@ async function read(ctx, journal, timeoutMs, external) {
         remove();
     }
 }
+/** Read current route support for context checks and selected writes without refreshing a token. */
+export async function verifyOnboardRoutes(ctx, binding, requirements, signal, timeoutMs = 30_000) {
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 30_000)
+        throw new Error("onboarding_capability_timeout_invalid");
+    const result = await read(ctx, binding, timeoutMs, signal);
+    if ("reason" in result)
+        return result;
+    if (requirements.some((route) => !result.capabilities.routes.has(routeKey(route))))
+        return { reason: "cloud_capability_unavailable", origin: result.origin };
+    return { origin: result.origin };
+}
 /** Guard both the observation and action before their first endpoint request. A route's real
  * refusal is preserved only after the same-account cloud advertised personal bearer support. */
 export function guardOnboardCapabilities(adapter, options) {
@@ -149,12 +160,9 @@ export function guardOnboardCapabilities(adapter, options) {
     if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 30_000)
         throw new Error("onboarding_capability_timeout_invalid");
     const run = async (ctx, journal, signal, requirements, work) => {
-        const advertised = await read(ctx, journal, timeoutMs, signal);
-        if ("reason" in advertised ||
-            requirements.some((route) => !advertised.capabilities.routes.has(routeKey(route)))) {
-            const reason = "reason" in advertised
-                ? advertised.reason
-                : "cloud_capability_unavailable";
+        const advertised = await verifyOnboardRoutes(ctx, journal, requirements, signal, timeoutMs);
+        if ("reason" in advertised) {
+            const reason = advertised.reason;
             const url = advertised.origin
                 ? `${advertised.origin}${safePages[options.fallback]}`
                 : undefined;

package/dist/onboard-capacity.js

@@ -0,0 +1,226 @@
+import { loadConfig, normalizeBaseUrl } from "./config.js";
+import { verifyOnboardRoutes } from "./onboard-capabilities.js";
+import { readExistingOnboardJson, selectedOnboardTeam, } from "./onboard-existing.js";
+import { readOnboardRepositoryInventory, selectedOnboardRepositories, } from "./onboard-repositories.js";
+const route = "/api/v1/me/runner-capacity";
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
+const integer = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+const text = (value) => typeof value === "string" &&
+    value.length > 0 &&
+    value.length <= 256 &&
+    !Array.from(value).some((c) => c.charCodeAt(0) < 32 || c.charCodeAt(0) === 127);
+const waiting = (reason) => ({
+    state: "waiting",
+    reason,
+});
+function snapshot(value, now) {
+    const body = object(value);
+    if (!body ||
+        body.status !== "ok" ||
+        body.scope !== "mapped-team-defaults" ||
+        !integer(body.observedAtMs) ||
+        body.observedAtMs < now - 30_000 ||
+        body.observedAtMs > now + 5_000 ||
+        !Array.isArray(body.buckets) ||
+        body.buckets.length > 500)
+        return null;
+    const buckets = [], seen = new Set(), seenTeam = new Set();
+    let totalTeams = 0;
+    for (const value of body.buckets) {
+        const b = object(value);
+        if (!b ||
+            !text(b.repoId) ||
+            seen.has(b.repoId) ||
+            !integer(b.effectiveLimit) ||
+            !integer(b.occupiedUnits) ||
+            !Array.isArray(b.teams) ||
+            !b.teams.length ||
+            b.teams.length > 500)
+            return null;
+        seen.add(b.repoId);
+        totalTeams += b.teams.length;
+        if (totalTeams > 1000)
+            return null;
+        const teams = [];
+        let minimum = Number.MAX_SAFE_INTEGER;
+        for (const value of b.teams) {
+            const t = object(value);
+            if (!t ||
+                !text(t.teamKey) ||
+                seenTeam.has(t.teamKey) ||
+                !integer(t.defaultLimit) ||
+                t.defaultLimit < 1 ||
+                !(t.configuredLimit === null ||
+                    (integer(t.configuredLimit) && t.configuredLimit > 0)) ||
+                typeof t.paused !== "boolean" ||
+                typeof t.admissionEnabled !== "boolean" ||
+                !integer(t.effectiveTeamLimit))
+                return null;
+            const configured = t.configuredLimit === null ? t.defaultLimit : t.configuredLimit;
+            if (t.source !== (t.configuredLimit === null ? "default" : "configured") ||
+                t.effectiveTeamLimit !== (t.paused ? 0 : configured))
+                return null;
+            const remaining = t.admissionEnabled
+                ? Math.max(0, b.effectiveLimit - b.occupiedUnits)
+                : null;
+            if (t.remainingUnits !== remaining)
+                return null;
+            seenTeam.add(t.teamKey);
+            minimum = Math.min(minimum, t.effectiveTeamLimit);
+            teams.push({ key: t.teamKey, admission: t.admissionEnabled, remaining });
+        }
+        if (minimum !== b.effectiveLimit)
+            return null;
+        buckets.push({
+            repo: b.repoId,
+            limit: b.effectiveLimit,
+            occupied: b.occupiedUnits,
+            teams,
+        });
+    }
+    return { at: body.observedAtMs, buckets };
+}
+function binding(ctx, journal) {
+    const cfg = loadConfig(ctx.home);
+    if (!cfg?.user ||
+        !["owner", "admin"].includes(cfg.user.role) ||
+        cfg.account !== (journal.account ?? journal.tenant) ||
+        cfg.user.id !== journal.membershipId ||
+        !journal.baseUrl ||
+        normalizeBaseUrl(cfg.baseUrl) !== normalizeBaseUrl(journal.baseUrl))
+        return null;
+    return JSON.stringify([
+        cfg.account,
+        cfg.user.id,
+        cfg.user.role,
+        normalizeBaseUrl(cfg.baseUrl),
+        cfg.permissions,
+        cfg.key ?? cfg.auth?.sessionId,
+    ]);
+}
+const selection = (journal) => JSON.stringify([
+    selectedOnboardTeam(journal),
+    selectedOnboardRepositories(journal),
+]);
+async function liveTeamKey(ctx, teamId, signal) {
+    const read = await readExistingOnboardJson(ctx, "/api/v1/agent/teams", signal);
+    if ("reason" in read)
+        return null;
+    const body = object(read.body), live = object(body?.liveTeamRead);
+    if (!body ||
+        !Array.isArray(body.teams) ||
+        body.teams.length > 1000 ||
+        (live?.error !== undefined && live.error !== null))
+        return null;
+    const ids = new Set(), keys = new Set();
+    let selected = null;
+    for (const value of body.teams) {
+        const team = object(value);
+        if (!team ||
+            !text(team.teamId) ||
+            !text(team.teamKey) ||
+            !/^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/.test(team.teamKey) ||
+            ids.has(team.teamId) ||
+            keys.has(team.teamKey))
+            return null;
+        ids.add(team.teamId);
+        keys.add(team.teamKey);
+        if (team.teamId === teamId)
+            selected = team.teamKey;
+    }
+    return selected;
+}
+async function liveIdentity(ctx, journal, signal) {
+    const read = await readExistingOnboardJson(ctx, "/api/v1/me", signal);
+    if ("reason" in read)
+        return false;
+    const me = object(read.body), user = object(me?.user), cfg = loadConfig(ctx.home);
+    return (!!cfg?.user &&
+        me?.account === (journal.account ?? journal.tenant) &&
+        user?.id === cfg.user.id &&
+        user.role === cfg.user.role &&
+        ["owner", "admin"].includes(cfg.user.role) &&
+        me?.principal === cfg.principal);
+}
+/** Fresh advisory for the selected team's DEFAULT mapped repo. It grants no lease and does not
+ * establish provider eligibility, host liveness or selected-repo overrides. No extra question. */
+export function onboardCapacityAdapter(input = {}) {
+    return {
+        check: async (ctx, journal, external) => {
+            if (external?.aborted)
+                return waiting("interrupted");
+            const expected = binding(ctx, journal), selected = selection(journal), teamId = selectedOnboardTeam(journal), repos = selectedOnboardRepositories(journal);
+            if (!expected)
+                return waiting("capacity_identity_unverified");
+            if (!teamId || repos.length !== 1 || repos[0].teamId !== teamId)
+                return waiting("capacity_context_unverified");
+            const controller = new AbortController(), signal = external
+                ? AbortSignal.any([external, controller.signal])
+                : controller.signal;
+            const timer = setTimeout(() => controller.abort(), 30_000);
+            const current = () => !signal.aborted &&
+                binding(ctx, journal) === expected &&
+                selection(journal) === selected;
+            const pause = (reason) => waiting(external?.aborted
+                ? "interrupted"
+                : controller.signal.aborted
+                    ? "capacity_unavailable"
+                    : reason);
+            try {
+                const support = await verifyOnboardRoutes(ctx, journal, [{ method: "GET", path: route }], signal);
+                if ("reason" in support)
+                    return pause(support.reason);
+                if (!current() ||
+                    !(await liveIdentity(ctx, journal, signal)) ||
+                    !current())
+                    return pause("capacity_identity_unverified");
+                const teamKey = await liveTeamKey(ctx, teamId, signal);
+                if (!teamKey || !current())
+                    return pause("capacity_context_unverified");
+                const inventory = await readOnboardRepositoryInventory(ctx, journal, signal);
+                if ("reason" in inventory ||
+                    !current() ||
+                    !inventory.repositories.some((r) => r.repoId === repos[0].repoId &&
+                        r.teamId === teamId &&
+                        r.owner.toLowerCase() === repos[0].owner.toLowerCase() &&
+                        r.name.toLowerCase() === repos[0].name.toLowerCase()))
+                    return pause("capacity_context_unverified");
+                const read = await readExistingOnboardJson(ctx, route, signal);
+                if ("reason" in read || !current())
+                    return pause("capacity_unavailable");
+                if (!(await liveIdentity(ctx, journal, signal)) || !current())
+                    return pause("capacity_identity_unverified");
+                const observed = snapshot(read.body, ctx.now().getTime());
+                const bucket = observed?.buckets.find((b) => b.repo === repos[0].repoId), mapped = bucket?.teams.find((t) => t.key === teamKey);
+                if (!observed || !bucket || !mapped)
+                    return pause("capacity_context_unverified");
+                if (!mapped.admission || mapped.remaining === null)
+                    return pause("capacity_admission_unverified");
+                if (mapped.remaining === 0)
+                    return pause("capacity_currently_full");
+                input.message?.(`Runner capacity observed: ${bucket.occupied} of ${bucket.limit} units in use. Starting work will check admission again.`);
+                if (!current())
+                    return pause("capacity_identity_unverified");
+                return {
+                    state: "done",
+                    evidence: {
+                        repoId: bucket.repo,
+                        effectiveLimit: bucket.limit,
+                        occupiedUnits: bucket.occupied,
+                        remainingUnits: mapped.remaining,
+                        observedAtMs: observed.at,
+                        advisory: true,
+                    },
+                };
+            }
+            catch {
+                return pause(external?.aborted ? "interrupted" : "capacity_unavailable");
+            }
+            finally {
+                clearTimeout(timer);
+            }
+        },
+    };
+}

package/dist/onboard-existing.js

@@ -1,12 +1,17 @@
 import { loadConfig, normalizeBaseUrl } from "./config.js";
 import { CliError } from "./errors.js";
 const idPattern = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
-const waiting = (reason) => ({ state: "waiting", reason });
-const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+const waiting = (reason) => ({
+    state: "waiting",
+    reason,
+});
+const object = (value) => value !== null && typeof value === "object" && !Array.isArray(value)
+    ? value
+    : null;
 const label = (value) => value.replace(/[\u0000-\u001f\u007f-\u009f]/g, "").slice(0, 120);
 /** A receipt keeps an explicit selection, never the team used to inspect the tenant grant. */
 export function selectedOnboardTeam(journal) {
-    const step = journal?.steps.find(row => row.id === "linear.team");
+    const step = journal?.steps.find((row) => row.id === "linear.team");
     const id = step?.state === "done" ? step.evidence?.team : undefined;
     return typeof id === "string" && idPattern.test(id) ? id : undefined;
 }
@@ -15,15 +20,23 @@ export async function readExistingOnboardJson(ctx, path, external) {
     const cfg = loadConfig(ctx.home);
     if (!cfg?.user)
         return { reason: "personal_login_required" };
+    const personId = cfg.user.id;
     // Identity verification refreshes before adapters run. These bounded reads never rotate a grant
     // that could finish after the engine has released its lock.
-    const expiry = cfg.auth ? Date.parse(cfg.auth.expiresAt) - ctx.now().getTime() : 0;
-    const bearer = cfg.key || (cfg.auth && Number.isFinite(expiry) && expiry > 30_000 ? cfg.auth.accessToken : undefined);
+    const expiry = cfg.auth
+        ? Date.parse(cfg.auth.expiresAt) - ctx.now().getTime()
+        : 0;
+    const bearer = cfg.key ||
+        (cfg.auth && Number.isFinite(expiry) && expiry > 30_000
+            ? cfg.auth.accessToken
+            : undefined);
     if (!bearer)
         return { reason: "team_read_login_refresh_required" };
     const deadline = new AbortController();
     const timer = setTimeout(() => deadline.abort(), 30_000);
-    const signal = external ? AbortSignal.any([external, deadline.signal]) : deadline.signal;
+    const signal = external
+        ? AbortSignal.any([external, deadline.signal])
+        : deadline.signal;
     let remove = () => { };
     try {
         return await new Promise((resolve, reject) => {
@@ -36,17 +49,32 @@ export async function readExistingOnboardJson(ctx, path, external) {
             }
             signal.addEventListener("abort", stopped, { once: true });
             remove = () => signal.removeEventListener("abort", stopped);
-            Promise.resolve().then(async () => {
+            Promise.resolve()
+                .then(async () => {
                 if (signal.aborted)
                     return { reason: "team_read_unavailable" };
                 const response = await ctx.fetch(`${normalizeBaseUrl(cfg.baseUrl)}${path}`, {
-                    headers: { authorization: `Bearer ${bearer}`, accept: "application/json" }, signal,
+                    redirect: "error",
+                    headers: {
+                        authorization: `Bearer ${bearer}`,
+                        accept: "application/json",
+                    },
+                    signal,
                 });
                 if (response.status !== 200)
                     return { reason: "team_read_unavailable" };
                 const body = await response.json();
+                const current = loadConfig(ctx.home);
+                if (!current?.user ||
+                    current.account !== cfg.account ||
+                    current.user.id !== personId ||
+                    normalizeBaseUrl(current.baseUrl) !== normalizeBaseUrl(cfg.baseUrl))
+                    return { reason: "team_read_identity_unverified" };
                 return { body };
-            }).then(value => signal.aborted ? stopped() : resolve(value), () => signal.aborted ? stopped() : resolve({ reason: "team_read_unavailable" }));
+            })
+                .then((value) => (signal.aborted ? stopped() : resolve(value)), () => signal.aborted
+                ? stopped()
+                : resolve({ reason: "team_read_unavailable" }));
         });
     }
     finally {
@@ -54,7 +82,7 @@ export async function readExistingOnboardJson(ctx, path, external) {
         remove();
     }
 }
-async function inventory(ctx, signal) {
+export async function readOnboardTeamInventory(ctx, signal) {
     const read = await readExistingOnboardJson(ctx, "/api/v1/agent/teams", signal);
     if ("reason" in read)
         return read;
@@ -68,11 +96,19 @@ async function inventory(ctx, signal) {
     const seen = new Set();
     for (const value of body.teams) {
         const row = object(value);
-        if (!row || typeof row.teamId !== "string" || !idPattern.test(row.teamId) || seen.has(row.teamId) ||
-            typeof row.teamKey !== "string" || typeof row.teamName !== "string")
+        if (!row ||
+            typeof row.teamId !== "string" ||
+            !idPattern.test(row.teamId) ||
+            seen.has(row.teamId) ||
+            typeof row.teamKey !== "string" ||
+            typeof row.teamName !== "string")
             return { reason: "team_inventory_shape" };
         seen.add(row.teamId);
-        teams.push({ id: row.teamId, key: label(row.teamKey), name: label(row.teamName) });
+        teams.push({
+            id: row.teamId,
+            key: label(row.teamKey),
+            name: label(row.teamName),
+        });
     }
     return { teams };
 }
@@ -82,14 +118,27 @@ async function observe(ctx, id, signal) {
         return null;
     const row = object(object(read.body)?.readiness);
     // The GET owns expiry/revision freshness. Do not invent an expiresAt absent from its wire shape.
-    if (!row || row.teamId !== id || typeof row.status !== "string" || !["ready", "degraded", "blocked"].includes(row.status) || typeof row.checkedAt !== "number" ||
-        !Number.isFinite(row.checkedAt) || row.checkedAt < 0 || row.checkedAt > ctx.now().getTime() ||
-        typeof row.workflowRev !== "number" || !Number.isSafeInteger(row.workflowRev) || row.workflowRev < 0 || !Array.isArray(row.checks))
+    if (!row ||
+        row.teamId !== id ||
+        typeof row.status !== "string" ||
+        !["ready", "degraded", "blocked"].includes(row.status) ||
+        typeof row.checkedAt !== "number" ||
+        !Number.isFinite(row.checkedAt) ||
+        row.checkedAt < 0 ||
+        row.checkedAt > ctx.now().getTime() ||
+        typeof row.workflowRev !== "number" ||
+        !Number.isSafeInteger(row.workflowRev) ||
+        row.workflowRev < 0 ||
+        !Array.isArray(row.checks))
         return null;
     const checks = new Map();
     for (const value of row.checks) {
         const check = object(value);
-        if (!check || typeof check.id !== "string" || checks.has(check.id) || typeof check.state !== "string" || !["pass", "fail", "unknown"].includes(check.state))
+        if (!check ||
+            typeof check.id !== "string" ||
+            checks.has(check.id) ||
+            typeof check.state !== "string" ||
+            !["pass", "fail", "unknown"].includes(check.state))
             return null;
         checks.set(check.id, check.state);
     }
@@ -100,17 +149,17 @@ export function existingLinearAdapters(args, choose) {
     const requested = (teams, journal) => {
         const explicit = args.flags.team;
         if (typeof explicit === "string") {
-            const ids = teams.filter(team => team.id === explicit);
+            const ids = teams.filter((team) => team.id === explicit);
             if (ids.length === 1)
                 return ids[0];
-            const keys = teams.filter(team => team.key === explicit);
+            const keys = teams.filter((team) => team.key === explicit);
             return keys.length === 1 ? keys[0] : undefined;
         }
         const saved = chosen ?? selectedOnboardTeam(journal);
-        return saved ? teams.find(team => team.id === saved) : undefined;
+        return saved ? teams.find((team) => team.id === saved) : undefined;
     };
     const teamCheck = async (ctx, journal, signal) => {
-        const list = await inventory(ctx, signal);
+        const list = await readOnboardTeamInventory(ctx, signal);
         if ("reason" in list)
             return waiting(list.reason);
         if (!list.teams.length)
@@ -124,23 +173,43 @@ export function existingLinearAdapters(args, choose) {
         const result = await observe(ctx, team.id, signal);
         if (!result || result.checks.get("team_visible") !== "pass")
             return waiting("team_selection_unverified");
-        return { state: "done", evidence: { team: team.id, teamKey: team.key, checkedAt: result.checkedAt, revision: result.revision } };
+        return {
+            state: "done",
+            evidence: {
+                team: team.id,
+                teamKey: team.key,
+                checkedAt: result.checkedAt,
+                revision: result.revision,
+            },
+        };
     };
     return {
-        "linear.workspace": { check: async (ctx, journal, signal) => {
-                const list = await inventory(ctx, signal);
+        "linear.workspace": {
+            check: async (ctx, journal, signal) => {
+                const list = await readOnboardTeamInventory(ctx, signal);
                 if ("reason" in list)
                     return waiting(list.reason);
                 const candidate = requested(list.teams, journal) ?? list.teams[0];
                 if (!candidate)
                     return waiting("linear_workspace_unverified");
                 const result = await observe(ctx, candidate.id, signal);
-                return result?.checks.get("oauth_scope") === "pass" && result.checks.get("token_live") === "pass"
-                    ? { state: "done", evidence: { checkedAt: result.checkedAt, revision: result.revision } }
+                return result?.checks.get("oauth_scope") === "pass" &&
+                    result.checks.get("token_live") === "pass"
+                    ? {
+                        state: "done",
+                        evidence: {
+                            checkedAt: result.checkedAt,
+                            revision: result.revision,
+                        },
+                    }
                     : waiting("linear_workspace_unverified");
-            }, act: async () => waiting("cloud_capability_unavailable") },
-        "linear.team": { check: teamCheck, act: async (ctx, journal, signal) => {
-                const list = await inventory(ctx, signal);
+            },
+            act: async () => waiting("cloud_capability_unavailable"),
+        },
+        "linear.team": {
+            check: teamCheck,
+            act: async (ctx, journal, signal) => {
+                const list = await readOnboardTeamInventory(ctx, signal);
                 if ("reason" in list)
                     return waiting(list.reason);
                 if (!list.teams.length)
@@ -156,14 +225,19 @@ export function existingLinearAdapters(args, choose) {
                     }
                     signal?.addEventListener("abort", stopped, { once: true });
                     remove = () => signal?.removeEventListener("abort", stopped);
-                    Promise.resolve().then(() => signal?.aborted ? null : choose(list.teams.map(team => ({ ...team })))).then(resolve, reject);
+                    Promise.resolve()
+                        .then(() => signal?.aborted
+                        ? null
+                        : choose(list.teams.map((team) => ({ ...team }))))
+                        .then(resolve, reject);
                 }).finally(() => remove());
                 if (!answer || signal?.aborted)
                     return waiting("interrupted");
-                if (!list.teams.some(team => team.id === answer))
+                if (!list.teams.some((team) => team.id === answer))
                     return waiting("team_selection_unverified");
                 chosen = answer;
                 return teamCheck(ctx, journal, signal);
-            } },
+            },
+        },
     };
 }