@trusty-squire/mcp 0.9.19-rc.2 → 0.9.19-rc.21

package/dist/install/cli.js

@@ -1,9 +1,9 @@
-// Setup CLI — install / logout / login subcommands.
+// Setup CLI — connect / settings / logout / login subcommands.
 //
-//   npx @trusty-squire/mcp install --target=claude-code
+//   npx @trusty-squire/mcp connect --target=claude-code
 //     Issues a machine token, then opens the trustysquire install-
 //     confirm page in the bot's own Chrome. The user signs in there
-//     once (Google or GitHub) — that single sign-in does TWO things:
+//     once with Google — that single sign-in does TWO things:
 //       (a) trustysquire claims the install and binds the machine to
 //           the user's account, and
 //       (b) the bot's Chrome profile gains a provider session it can
@@ -26,14 +26,7 @@
 //                        their own browser (CI / scripted installs)
 //   --proxy-url=<url>    bake a residential proxy into the MCP config's
 //                        env (UNIVERSAL_BOT_PROXY_URL)
-//   --registry-url=<url> override the default skill registry URL
-//                        (default: https://registry.trustysquire.ai).
-//                        Baked into the MCP config's env as
-//                        TRUSTY_SQUIRE_REGISTRY_URL so the Tier-2
-//                        router is on out of the box.
-//   --no-registry        omit TRUSTY_SQUIRE_REGISTRY_URL from the
-//                        config → mcp skips the router entirely and
-//                        every signup goes through the universal bot
+//   --no-registry        disable managed registry participation
 //
 // Pure module — `runCli()` is invoked by bin.ts. No shebang, no
 // entrypoint guard, no top-level execution.
@@ -41,7 +34,6 @@ import process from "node:process";
 import { cpSync, rmSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { createInterface } from "node:readline";
 import { loadHarvesterEnvFile } from "../operator-env.js";
 import { fileURLToPath } from "node:url";
 import { installInitiate, installPoll, issueMachineToken } from "../api-client.js";
@@ -50,42 +42,35 @@ import { AGENTS, detectInstalledAgents, writeClaudeCodePermissions, } from "./ag
 import { detectAsn } from "../bot/index.js";
 import { detectActiveProviderSessions, ensureOAuthSession, openInstallConfirmInBotChrome, } from "../bot/google-login.js";
 import {} from "../bot/oauth-providers.js";
-import { clearAllProviderMarkers, clearProviderCookies, clearProviderLoggedIn, loggedInProviders, markProviderLoggedIn, } from "../bot/login-state.js";
+import { clearAllProviderMarkers, clearBrowserProfile, clearProviderCookies, clearProviderLoggedIn, loggedInProviders, markProviderLoggedIn, } from "../bot/login-state.js";
+import { waitForProfileFree } from "../bot/profile.js";
 import { VERSION } from "../version.js";
 import * as ui from "./ui.js";
-import { runInteractiveSetup, shouldRunInteractive, showOutro } from "./interactive.js";
+import { runInteractiveSetup, runSettingsSetup, shouldRunInteractive, showOutro, } from "./interactive.js";
 import chalk from "chalk";
+import { normalizeProxyUrl } from "./proxy-url.js";
 const DEFAULT_API_BASE = process.env.TRUSTY_SQUIRE_API_BASE ?? "https://trusty-squire-api.fly.dev";
-// Default skill-registry URL. Wired into the MCP config's env block
-// so users don't have to set it manually — without it, mcp skips the
-// Tier-2 router and every signup goes through the universal bot
-// (fail-open by design, but a worse experience than just using the
-// closed loop).
-const DEFAULT_REGISTRY_URL = process.env.TRUSTY_SQUIRE_REGISTRY_URL ?? "https://registry.trustysquire.ai";
+// Managed skill-registry URL. Advanced setup decides whether this is written
+// into the MCP config; the URL itself is product-owned and not user-editable.
+const DEFAULT_REGISTRY_URL = "https://registry.trustysquire.ai";
 function parseArgs(argv) {
     const positional = argv.filter((a) => !a.startsWith("--"));
-    // `connect` is the canonical command as of 0.6.14. `install` is kept
-    // as a hidden alias so any docs/scripts/blog-posts published against
-    // ≤0.6.13 still work — it emits a one-line deprecation notice but
-    // otherwise behaves identically. Default (no positional) → `connect`
-    // because the most common invocation is `npx @trusty-squire/mcp` with
-    // no args, and that should still kick off the setup flow.
-    let command = positional[0] ?? "connect";
+    // Default (no positional) → `connect` because the most common invocation is
+    // `npx @trusty-squire/mcp` with no args, and that should kick off setup.
+    const command = positional[0] ?? "connect";
     if (command === "install") {
-        console.warn("[trusty-squire] `install` is now `connect`. " +
-            "This alias still works but will be removed in a future major. " +
-            "Update your docs/scripts to: `npx @trusty-squire/mcp connect`.");
-        command = "connect";
+        rejectDeprecatedCli("`install` has been removed. Use `npx @trusty-squire/mcp connect`.");
     }
     let target;
     let apiBase = DEFAULT_API_BASE;
     let proxyUrl;
-    let registryUrl;
     let noRegistry = false;
+    let registryConfigured = false;
     let providerArg;
     let profileDir;
     let skipBrowser = false;
     let forceRelogin = false;
+    let forceReloginProvider;
     let noInteractive = false;
     for (const arg of argv) {
         if (arg.startsWith("--target=")) {
@@ -103,13 +88,23 @@ function parseArgs(argv) {
             apiBase = arg.slice("--api-base=".length);
         }
         else if (arg.startsWith("--proxy-url=")) {
-            proxyUrl = arg.slice("--proxy-url=".length);
+            const rawProxyUrl = arg.slice("--proxy-url=".length);
+            const normalized = normalizeProxyUrl(rawProxyUrl);
+            if (rawProxyUrl.length > 0 && normalized === undefined) {
+                console.error("invalid --proxy-url. Use http://user:pass@host:port or socks5://host:port.");
+                process.exit(64);
+            }
+            proxyUrl = normalized;
         }
         else if (arg.startsWith("--registry-url=")) {
-            registryUrl = arg.slice("--registry-url=".length);
+            rejectDeprecatedCli("`--registry-url` has been removed. Trusty Squire uses the managed skill registry.");
         }
         else if (arg === "--no-registry") {
             noRegistry = true;
+            registryConfigured = true;
+        }
+        else if (arg === "--registry") {
+            rejectDeprecatedCli("`--registry` has been removed because the managed registry is enabled by default.");
         }
         else if (arg.startsWith("--provider=")) {
             const p = arg.slice("--provider=".length);
@@ -119,18 +114,23 @@ function parseArgs(argv) {
         else if (arg.startsWith("--profile-dir=")) {
             profileDir = arg.slice("--profile-dir=".length);
         }
-        else if (arg === "--skip-browser" || arg === "--skip-login") {
-            // --skip-login kept as an alias for the 0.5.0 spelling so any
-            // scripted callers still work.
+        else if (arg === "--skip-browser") {
             skipBrowser = true;
         }
+        else if (arg === "--skip-login") {
+            rejectDeprecatedCli("`--skip-login` has been removed. Use `--skip-browser`.");
+        }
         else if (arg === "--force-relogin") {
             forceRelogin = true;
         }
+        else if (arg.startsWith("--force-relogin=")) {
+            forceRelogin = true;
+            const p = arg.slice("--force-relogin=".length);
+            if (p === "google" || p === "github")
+                forceReloginProvider = p;
+        }
         else if (arg === "--skip-secondary") {
-            // No-op: kept as a flag for backwards-compat. The 0.8.2 wizard
-            // collapsed step 1 + step 2 into one browser session, so there
-            // is no "secondary" stage left to skip.
+            rejectDeprecatedCli("`--skip-secondary` has been removed; connect is single-stage.");
         }
         else if (arg === "--no-interactive") {
             noInteractive = true;
@@ -141,21 +141,25 @@ function parseArgs(argv) {
         apiBase,
         skipBrowser,
         forceRelogin,
+        ...(forceReloginProvider !== undefined ? { forceReloginProvider } : {}),
         noRegistry,
+        ...(registryConfigured ? { registryConfigured } : {}),
         noInteractive,
     };
     if (target !== undefined)
         args.target = target;
     if (proxyUrl !== undefined && proxyUrl.length > 0)
         args.proxyUrl = proxyUrl;
-    if (registryUrl !== undefined && registryUrl.length > 0)
-        args.registryUrl = registryUrl;
     if (providerArg !== undefined)
         args.providerArg = providerArg;
     if (profileDir !== undefined && profileDir.length > 0)
         args.profileDir = profileDir;
     return args;
 }
+function rejectDeprecatedCli(message) {
+    console.error(`[trusty-squire] ${message}`);
+    process.exit(64);
+}
 function isAgentTarget(s) {
     // Source of truth is AGENTS — adding/removing a target there auto-
     // propagates here, so a new agent (or a removed one) can't drift the
@@ -168,23 +172,14 @@ function isAgentTarget(s) {
 //    that points at a permanent path. Use the absolute bin.js path
 //    directly. Deterministic, offline, fast.
 //
-// 2. Ephemeral + stable version — the CLI was invoked via
-//    `npx @trusty-squire/mcp@X.Y.Z`, which copies the package into
-//    npx's throwaway cache. The cache CAN get swept, so we don't
-//    pin the cache path; instead we write `npx @trusty-squire/mcp@<version>`
-//    so the launch re-resolves against npm every time. Works as
-//    long as the version is on the public npm registry.
-//
-// 3. Ephemeral + prerelease version — the CLI was invoked via
-//    `npx <tarball-url>` (the GitHub-Release test pattern). The
-//    version isn't on npm, so case 2 would fail with `ETARGET`.
-//    We instead copy the package out of the ephemeral cache into
-//    `~/.trusty-squire/lib/mcp` and write a `node <stable>/dist/bin.js`
-//    launch. The stable copy survives npx-cache cleanup; if the user
-//    re-installs they overwrite it.
-//
-// Prerelease detection: semver prerelease versions carry a `-` (e.g.
-// `0.6.0-rc.1`). Stable versions don't. Cheap, reliable.
+// 2. Ephemeral — the CLI was invoked via npx, which copies the package into
+//    npx's throwaway cache. The cache CAN get swept, so never pin the cache
+//    path into a host agent config. Instead write
+//    `npx -y @trusty-squire/mcp@<version> server`, which re-resolves the exact
+//    published version on each agent launch. This matters for RCs: prerelease
+//    versions are published to npm on the `next` tag, so treating every
+//    prerelease as a non-registry tarball leaves Goose pointing at dead npx
+//    cache paths and stale tool schemas.
 /**
  * Copy an npx-style node_modules tree to a stable location.
  *
@@ -221,11 +216,14 @@ function resolveServerLaunch() {
     if (!ephemeral) {
         return { command: process.execPath, args: [binPath, "server"] };
     }
-    const isPrerelease = VERSION.includes("-");
-    if (!isPrerelease) {
-        return { command: "npx", args: ["-y", `@trusty-squire/mcp@${VERSION}`, "server"] };
-    }
-    // Prerelease from GitHub Releases — copy the package PLUS the
+    return { command: "npx", args: ["-y", `@trusty-squire/mcp@${VERSION}`, "server"] };
+}
+// Historical fallback for GitHub-release tarball installs. The normal install
+// path no longer calls this because RCs are published to npm and host configs
+// must not pin npx cache paths. Kept exported for the regression tests around
+// copying broken npx symlink trees.
+function resolveCopiedNpxServerLaunch(binPath) {
+    // Copy the package PLUS the
     // ephemeral cache's entire `node_modules` to a stable location.
     //
     // We need both because the package imports @modelcontextprotocol/sdk,
@@ -286,6 +284,9 @@ export async function runCli(argv) {
         case "login":
             await login(args);
             return;
+        case "settings":
+            await settings(args);
+            return;
         case "help":
             printHelp();
             return;
@@ -295,11 +296,58 @@ export async function runCli(argv) {
             process.exit(64);
     }
 }
+async function settings(args) {
+    const storage = await openSessionStorage();
+    const session = await storage.read();
+    if (session === null) {
+        ui.fail(`No local Trusty Squire session found. Run ${ui.code("npx @trusty-squire/mcp connect")} first.`);
+        process.exit(1);
+    }
+    if (!args.noInteractive && process.stdin.isTTY === true) {
+        const picker = await runSettingsSetup({
+            ...(args.target !== undefined ? { initialTarget: args.target } : {}),
+            ...(session.proxy_url !== undefined ? { initialProxyUrl: session.proxy_url } : {}),
+            initialRegistryEnabled: session.consent_skillify_telemetry === true,
+            initialConsentOperatorInboxOtp: session.consent_operator_inbox_otp === true,
+        });
+        args.target = picker.target;
+        if (picker.proxyUrl !== undefined)
+            args.proxyUrl = picker.proxyUrl;
+        args.noRegistry = !picker.registryEnabled;
+        args.advancedConfigured = true;
+        args.consentOperatorInboxOtp = picker.consentOperatorInboxOtp === true;
+    }
+    else {
+        if (args.target === undefined) {
+            ui.fail(`Pass ${ui.code("--target=<agent>")} when running settings outside an interactive terminal.`);
+            process.exit(64);
+        }
+        if (args.registryConfigured !== true) {
+            args.noRegistry = session.consent_skillify_telemetry !== true;
+        }
+        if (args.proxyUrl === undefined && session.proxy_url !== undefined) {
+            args.proxyUrl = session.proxy_url;
+        }
+    }
+    const target = await resolveTarget(args.target);
+    const agent = AGENTS[target];
+    const updated = {
+        ...session,
+        saved_at: new Date().toISOString(),
+        consent_skillify_telemetry: !args.noRegistry,
+        consent_operator_inbox_otp: args.consentOperatorInboxOtp === true,
+        ...(args.proxyUrl !== undefined && args.proxyUrl.trim().length > 0
+            ? { proxy_url: args.proxyUrl.trim() }
+            : {}),
+    };
+    await storage.write(updated);
+    await writeAgentConfig(target, agent, args);
+    ui.success(`${agent.display_name} settings saved.`);
+}
 async function connect(args) {
-    // 0.8.1 — interactive picker (clack), Goose-flavored. Walks the
-    // user through agent / OAuth providers / LLM choice / advanced
-    // before the install ceremony fires. The picker fills in args so
-    // the rest of this function is unchanged.
+    // Interactive picker (clack). Walks the user through agent + advanced setup
+    // before the browser install ceremony fires. The picker fills in args so the
+    // rest of this function is unchanged.
     const wantInteractive = !args.noInteractive &&
         shouldRunInteractive({
             hasTty: process.stdin.isTTY === true,
@@ -311,12 +359,11 @@ async function connect(args) {
         // 0.8.2 — picker no longer asks about OAuth providers. The
         // install wizard rendered in the bot's Chrome handles the
         // Google + (optional) GitHub flow directly; the CLI just
-        // surfaces agent + LLM + advanced.
+        // surfaces agent + advanced.
         const picker = await runInteractiveSetup({
             ...(args.target !== undefined ? { initialTarget: args.target } : {}),
             ...(args.proxyUrl !== undefined ? { initialProxyUrl: args.proxyUrl } : {}),
-            ...(args.registryUrl !== undefined ? { initialRegistryUrl: args.registryUrl } : {}),
-            registryEnabled: !args.noRegistry,
+            initialRegistryEnabled: !args.noRegistry,
         });
         args.target = picker.target;
         args.llmChoice = picker.llmChoice;
@@ -324,11 +371,10 @@ async function connect(args) {
             args.byokKey = picker.byokKey;
         if (picker.proxyUrl !== undefined)
             args.proxyUrl = picker.proxyUrl;
-        if (!picker.registryEnabled) {
-            args.noRegistry = true;
-        }
-        else if (picker.registryUrl !== undefined) {
-            args.registryUrl = picker.registryUrl;
+        args.noRegistry = !picker.registryEnabled;
+        args.advancedConfigured = picker.advancedConfigured;
+        if (picker.consentOperatorInboxOtp !== undefined) {
+            args.consentOperatorInboxOtp = picker.consentOperatorInboxOtp;
         }
     }
     else {
@@ -337,26 +383,33 @@ async function connect(args) {
     }
     const target = await resolveTarget(args.target);
     const agent = AGENTS[target];
-    // Preflight: an existing install that's fully provisioned (machine
-    // token + agent session token + a bot Google session marker) doesn't
-    // need to redo the browser confirm. Just rewrite the MCP config in
-    // place so the host agent picks up the latest server entrypoint and
-    // env. Pass --force-relogin to bypass (e.g. to switch Google account).
+    // Preflight: an existing install is "connected" only when BOTH the
+    // account-bound plumbing still works and the bot profile has a confirmed
+    // Google session. A bare machine/agent token can talk to Trusty Squire, but
+    // it cannot act as the user at third-party sites, so it must not skip the
+    // browser confirm. Pass --force-relogin to bypass (e.g. to switch Google).
     if (!args.forceRelogin) {
         const preflight = await checkAlreadyProvisioned();
         if (preflight !== null) {
             ui.divider();
+            await hydrateArgsFromStoredPreferences(args);
+            await ensureConsentRecorded(consentFromArgs(args), args.advancedConfigured === true);
             await writeAgentConfig(target, agent, args);
-            const provNote = preflight.providers.length > 0
-                ? `Already provisioned (${preflight.providers.join(" + ")}).`
-                : `Session valid — no bot OAuth login on this machine yet ` +
-                    `(run ${ui.code("npx @trusty-squire/mcp login")} to enable ` +
-                    `OAuth-preferring signups).`;
-            ui.success(`${provNote} ${agent.display_name} config refreshed.`);
+            ui.success(`Already connected (${preflight.providers.join(" + ")}). ` +
+                `${agent.display_name} config refreshed.`);
+            printProviderState(preflight.providers);
             // Backfill connected_providers from the bot-side marker on
             // pre-rc.5 sessions, so the preflight cache is current.
             for (const p of preflight.providers)
                 await recordConnectedProvider(p);
+            // "Skipped but dead" notice (DESIGN-connect-session-validation): we
+            // short-circuited because Google is valid, but if the bot's GitHub session
+            // validated as dead, say so — a dead session must never be silently
+            // hidden. GitHub is optional, so we don't raise the ceremony for it; the
+            // user refreshes it explicitly when a GitHub-only service needs it.
+            if (!preflight.providers.includes("github")) {
+                ui.hint(`GitHub session is not active — run ${ui.code("npx @trusty-squire/mcp connect --force-relogin=github")} if a service needs GitHub.`);
+            }
             ui.hint(`Pass ${ui.code("--force-relogin")} to switch accounts.`);
             return;
         }
@@ -364,13 +417,64 @@ async function connect(args) {
     console.warn("");
     console.warn("Opening the Trusty Squire install page in a browser. " +
         "The page walks you through signing in with Google and (optionally) GitHub.");
-    // --force-relogin means "redo the OAuth dance from scratch" — wipe
-    // the bot's profile cookies + marker so the install wizard sees a
-    // clean slate. The user signs in fresh inside the bot Chrome.
+    // --force-relogin means "redo the OAuth dance from scratch". The scoped
+    // form clears only one provider; bare --force-relogin is the full-profile
+    // account-switch escape hatch.
     if (args.forceRelogin) {
-        clearAllProviderMarkers();
-        await clearProviderCookies();
+        if (args.forceReloginProvider !== undefined) {
+            clearProviderLoggedIn(args.forceReloginProvider);
+        }
+        else {
+            clearAllProviderMarkers();
+        }
+        const free = await waitForProfileFree(undefined, {
+            deadlineMs: 120_000,
+            onWait: () => ui.hint("Waiting for the bot browser to finish before clearing the old session…"),
+        });
+        if (!free) {
+            ui.fail("The bot browser is still using the profile, so I can't safely switch accounts yet. " +
+                "Close the running signup/login browser and retry with --force-relogin.");
+            process.exit(1);
+        }
+        if (args.forceReloginProvider !== undefined) {
+            await clearProviderCookies(undefined, args.forceReloginProvider);
+        }
+        else {
+            clearBrowserProfile();
+            await clearProviderCookies();
+        }
     }
+    // DESIGN-connect-session-validation: a SCOPED force-relogin=github on an
+    // already-bound account is a GitHub-only login — Google's gate is already
+    // satisfied (the account is bound + its session is what we'd re-bind), so we
+    // must NOT drag the Google-first account-binding confirm page into it. Route
+    // straight to the provider-scoped login (the `login --provider=github` path):
+    // it opens a GitHub-only login (account chooser, since cookies were cleared
+    // above), never touching Google. Falls through to the full confirm flow only
+    // when the account isn't bound yet (nothing to skip) or the scope is google
+    // (which can re-bind the account and so needs the claim).
+    if (args.forceReloginProvider === "github") {
+        const bound = await checkAlreadyBound();
+        if (bound) {
+            ui.heading("Sign in to GitHub");
+            const result = await ensureOAuthSession({
+                provider: "github",
+                apiBaseUrl: args.apiBase,
+                forceOpen: true,
+            });
+            if (result.status === "logged_in" || result.status === "already_valid") {
+                await recordConnectedProvider("github");
+                await writeAgentConfig(target, agent, args);
+                ui.success("Signed in to GitHub. The bot is ready; config refreshed.");
+                return;
+            }
+            ui.fail(result.status === "timeout"
+                ? `GitHub sign-in timed out. Retry: ${ui.code("npx @trusty-squire/mcp connect --force-relogin=github")}`
+                : `GitHub sign-in failed: ${result.detail ?? "unknown error"}`);
+            process.exit(1);
+        }
+    }
+    const consent = consentFromArgs(args);
     // Detect egress class so the asn rides along in the install payload
     // (API uses it to correlate captcha failures with network class).
     // Best-effort: a failure returns null and the install continues.
@@ -407,6 +511,8 @@ async function connect(args) {
         api_base_url: args.apiBase,
         saved_at: new Date().toISOString(),
         machine_token: machine.machine_token,
+        consent_skillify_telemetry: consent.skillifyTelemetry,
+        consent_operator_inbox_otp: consent.operatorInboxOtp,
     };
     const session = await runInstallClaim(args.apiBase, target, baseSession, args.skipBrowser);
     if (session === null) {
@@ -417,6 +523,10 @@ async function connect(args) {
     const storage = await openSessionStorage();
     await storage.write(session);
     ui.success(`Session saved (${storage.backendName()})`);
+    args.noRegistry = session.consent_skillify_telemetry !== true;
+    args.consentOperatorInboxOtp = session.consent_operator_inbox_otp === true;
+    if (session.proxy_url !== undefined)
+        args.proxyUrl = session.proxy_url;
     // 0.8.1 — the bot's persistent profile may have a stale provider
     // marker from a previous install (the marker is sticky on disk).
     // The install confirm above only seeded one provider (whichever
@@ -429,6 +539,8 @@ async function connect(args) {
             start: "Checking provider sessions",
             done: "Provider sessions checked",
             fail: () => "Provider session check failed (continuing)",
+            // validate=true: confirm each session is LIVE (not just cookie-present),
+            // so a dead-but-present GitHub session isn't shown as connected.
             task: () => detectActiveProviderSessions(),
         });
         if (actual !== null) {
@@ -446,8 +558,10 @@ async function connect(args) {
         // reach GitHub even if we mis-identified the live state.
     }
     // Backfill connected_providers from the (now-fresh) bot-side marker.
-    for (const p of loggedInProviders())
+    const providers = loggedInProviders();
+    for (const p of providers)
         await recordConnectedProvider(p);
+    printProviderState(providers);
     await writeAgentConfig(target, agent, args);
     if (args.skipBrowser) {
         ui.panel(`--skip-browser was set, so the bot's Chrome didn't observe your sign-in.\n` +
@@ -468,6 +582,27 @@ async function connect(args) {
         ui.panel(closingLine, { color: "wine" });
     }
 }
+async function hydrateArgsFromStoredPreferences(args) {
+    if (args.advancedConfigured === true)
+        return;
+    try {
+        const session = await (await openSessionStorage()).read();
+        if (session === null)
+            return;
+        args.noRegistry = session.consent_skillify_telemetry !== true;
+        args.consentOperatorInboxOtp = session.consent_operator_inbox_otp === true;
+        if (session.proxy_url !== undefined)
+            args.proxyUrl = session.proxy_url;
+    }
+    catch {
+        // Best-effort. Missing preferences fall back to the privacy-safe defaults.
+    }
+}
+function printProviderState(providers) {
+    const have = new Set(providers);
+    ui.hint(`  Provider sessions: Google ${have.has("google") ? "connected" : "not connected"}; ` +
+        `GitHub ${have.has("github") ? "connected" : "not connected"}`);
+}
 // Runs the browser-based install confirm flow.
 //
 // Default path (`skipBrowser=false`): opens the trustysquire confirm
@@ -483,9 +618,9 @@ async function connect(args) {
 // provider session afterwards — the user must run `mcp login` before
 // their first OAuth signup. This path is for CI / scripted installs.
 // True when the local session + bot profile already carry everything
-// install would establish. Returns the list of provider sessions
-// detected, or null when anything's missing. Best-effort: any read
-// error returns null and the caller proceeds with the normal flow.
+// connect would establish. Returns the list of confirmed provider sessions, or
+// null when anything's missing. Best-effort: any read/probe error returns null
+// and the caller proceeds with the normal browser flow.
 // Probe whether the stored agent token still authenticates. Agent
 // sessions have a 24h absolute cap, so a token can be PRESENT in the
 // session file but already dead on the server. Treating present as
@@ -507,19 +642,15 @@ export async function agentTokenStillValid(apiBaseUrl, token, fetchImpl = fetch)
         return true;
     }
 }
-// Pure gate for the `connect` fast path: given the read session, whether
-// its agent token still validated, and the bot's provider markers, decide
-// whether connect can (re)write the MCP config WITHOUT a browser re-claim.
+// Pure gate for the `connect` fast path: given the read session, whether its
+// agent token still validated, and the bot's confirmed provider sessions,
+// decide whether connect can (re)write the MCP config WITHOUT a browser
+// re-claim.
 //
-// The provider marker is INFORMATIONAL — it tells the signup bot which
-// providers to auto-prefer for OAuth, NOT whether the host agent can be
-// wired up. A valid session (machine + agent token that just validated)
-// is sufficient. Gating on a non-empty marker used to force a full
-// browser re-claim on any box whose bot profile had no login yet (a fresh
-// machine that restored session.json, or a headless box where the claim
-// browser can't run) — leaving the user with NO config written and no
-// clear reason. So an empty `providers` is fine; we still return
-// provisioned. Exported for unit tests.
+// Account-bound plumbing is not enough. The product-level connection is the
+// bot-profile Google session: without it the host agent may be able to call the
+// Trusty Squire API, but cannot act as the user at third-party services.
+// GitHub is optional headroom; Google is the required primary identity.
 export function decideProvisioned(session, tokenValid, providers) {
     if (session === null ||
         session.machine_token === undefined ||
@@ -529,6 +660,8 @@ export function decideProvisioned(session, tokenValid, providers) {
     }
     if (!tokenValid)
         return null;
+    if (!providers.includes("google"))
+        return null;
     return { providers };
 }
 async function checkAlreadyProvisioned() {
@@ -545,12 +678,60 @@ async function checkAlreadyProvisioned() {
         }
         // Don't short-circuit on a present-but-expired token — re-pair.
         const stillValid = await agentTokenStillValid(session.api_base_url, session.agent_session_token);
-        return decideProvisioned(session, stillValid, loggedInProviders());
+        // Probe the profile cookies instead of trusting the marker. The marker is a
+        // cache that can lie after logout/expiry; connect is rare enough to pay this
+        // cost, and this keeps "Already connected" aligned with the bot's real
+        // ability to wear the user's Google identity. validate=true so a dead-but-
+        // present GitHub session isn't persisted into connected_providers.
+        const providers = await detectActiveProviderSessions();
+        await syncConnectedProviders(providers);
+        return decideProvisioned(session, stillValid, providers);
     }
     catch {
         return null;
     }
 }
+// Is the account already BOUND? — a valid session (machine + agent token +
+// account id) whose agent token still validates. Unlike checkAlreadyProvisioned
+// this does NOT require a live Google session: it answers "is the install
+// claimed to an account", which is what a scoped GitHub force-relogin needs to
+// know it can skip the Google-binding confirm page.
+async function checkAlreadyBound() {
+    try {
+        const storage = await openSessionStorage();
+        const session = await storage.read();
+        if (session === null ||
+            session.machine_token === undefined ||
+            session.agent_session_token === undefined ||
+            session.account_id === undefined) {
+            return false;
+        }
+        return await agentTokenStillValid(session.api_base_url, session.agent_session_token);
+    }
+    catch {
+        return false;
+    }
+}
+async function syncConnectedProviders(providers) {
+    clearAllProviderMarkers();
+    for (const p of providers)
+        markProviderLoggedIn(p);
+    try {
+        const storage = await openSessionStorage();
+        const session = await storage.read();
+        if (session === null)
+            return;
+        await storage.write({
+            ...session,
+            connected_providers: [...providers],
+            saved_at: new Date().toISOString(),
+        });
+    }
+    catch {
+        // Best-effort — marker/session drift only affects fast-path UX. The next
+        // connect/login/provision probe can repair it.
+    }
+}
 // Persist `provider` into session.connected_providers (idempotent).
 // Called after a successful ensureOAuthSession so the install
 // preflight on the next run can read both providers off the session
@@ -579,26 +760,33 @@ async function recordConnectedProvider(provider) {
         // which is recoverable.
     }
 }
-// Y/n prompt with a default answer. Returns true on yes, false on no.
-// Default is taken when the user just hits enter or when stdin isn't
-// a TTY (CI / scripted contexts). Designed to match what the user
-// expects from common CLI tooling — `[Y/n]` means default-yes.
-async function promptYesNo(message, defaultYes) {
-    if (!process.stdin.isTTY)
-        return defaultYes;
-    const suffix = defaultYes ? "[Y/n]" : "[y/N]";
-    const rl = createInterface({ input: process.stdin, output: process.stderr });
+function consentFromArgs(args) {
+    return {
+        skillifyTelemetry: !args.noRegistry,
+        operatorInboxOtp: args.consentOperatorInboxOtp === true,
+    };
+}
+async function ensureConsentRecorded(consent, overwrite) {
     try {
-        const answer = await new Promise((resolve) => {
-            rl.question(`${message} ${suffix} `, resolve);
+        const storage = await openSessionStorage();
+        const session = await storage.read();
+        if (session === null)
+            return;
+        if (!overwrite &&
+            session.consent_skillify_telemetry !== undefined &&
+            session.consent_operator_inbox_otp !== undefined) {
+            return;
+        }
+        await storage.write({
+            ...session,
+            saved_at: new Date().toISOString(),
+            consent_skillify_telemetry: consent.skillifyTelemetry,
+            consent_operator_inbox_otp: consent.operatorInboxOtp,
         });
-        const trimmed = answer.trim().toLowerCase();
-        if (trimmed.length === 0)
-            return defaultYes;
-        return trimmed === "y" || trimmed === "yes";
     }
-    finally {
-        rl.close();
+    catch {
+        // Best-effort. If we can't persist consent, runtime treats missing
+        // fields as not approved.
     }
 }
 // Writes the host agent's MCP config — extracted so both the normal
@@ -616,17 +804,14 @@ async function writeAgentConfig(target, agent, args) {
     if (args.proxyUrl !== undefined) {
         env.UNIVERSAL_BOT_PROXY_URL = args.proxyUrl;
     }
-    // Skill registry URL — wired by default so the Tier-2 router is on
-    // out of the box. Override with --registry-url=<url>; opt out
-    // entirely with --no-registry (which omits the var → router skips).
+    // Skill registry URL. The endpoint is not user-configurable; Advanced setup
+    // controls whether it is written at all. Registry participation is also the
+    // user's consent to contribute successful non-personal signup recipes.
     if (!args.noRegistry) {
-        env.TRUSTY_SQUIRE_REGISTRY_URL = args.registryUrl ?? DEFAULT_REGISTRY_URL;
+        env.TRUSTY_SQUIRE_REGISTRY_URL = DEFAULT_REGISTRY_URL;
     }
-    // 0.8.1 — LLM choice from the interactive picker (or future
-    // --llm/--byok-key flags). BYOK paths write the provider key as
-    // env; the server's LLM client picks the matching path. The
-    // managed-free path omits keys entirely so the server routes
-    // through our proxy (the rate-limited /v1/llm/chat endpoint).
+    // Legacy LLM env support. Signup navigation is session-agent driven now, so
+    // normal installs never set these fields; keep the switch for older callers.
     switch (args.llmChoice) {
         case "byok_openrouter":
             if (args.byokKey !== undefined)
@@ -665,10 +850,7 @@ async function writeAgentConfig(target, agent, args) {
         ui.hint(`  Residential proxy baked in: ${args.proxyUrl}`);
     }
     if (args.noRegistry) {
-        ui.hint("  Skill registry disabled (--no-registry) — every signup goes through the universal bot");
-    }
-    else if (args.registryUrl !== undefined) {
-        ui.hint(`  Skill registry: ${args.registryUrl}`);
+        ui.hint("  Skill registry disabled — every signup goes through the universal bot");
     }
 }
 // A confirm-flow page URL that means the claim is finished and the
@@ -716,6 +898,9 @@ async function runInstallClaim(apiBase, target, baseSession, skipBrowser) {
                 state.value = {
                     token: status.agent_session_token,
                     account_id: status.account_id ?? "",
+                    ...(status.install_preferences !== undefined
+                        ? { preferences: status.install_preferences }
+                        : {}),
                 };
             }
             else if (status.status === "expired") {
@@ -761,7 +946,7 @@ async function runInstallClaim(apiBase, target, baseSession, skipBrowser) {
         if (ok === null)
             return null;
         return {
-            ...baseSession,
+            ...applyInstallPreferences(baseSession, ok.preferences),
             api_base_url: apiBase,
             saved_at: new Date().toISOString(),
             agent_session_token: ok.token,
@@ -792,13 +977,24 @@ async function runInstallClaim(apiBase, target, baseSession, skipBrowser) {
         return null;
     }
     return {
-        ...baseSession,
+        ...applyInstallPreferences(baseSession, state.value.preferences),
         api_base_url: apiBase,
         saved_at: new Date().toISOString(),
         agent_session_token: state.value.token,
         account_id: state.value.account_id,
     };
 }
+function applyInstallPreferences(baseSession, preferences) {
+    if (preferences === undefined)
+        return baseSession;
+    const proxy = preferences.proxy_url?.trim();
+    return {
+        ...baseSession,
+        consent_skillify_telemetry: preferences.registry_enabled === true,
+        consent_operator_inbox_otp: preferences.consent_operator_inbox_otp === true,
+        ...(proxy !== undefined && proxy.length > 0 ? { proxy_url: proxy } : {}),
+    };
+}
 async function resolveTarget(explicit) {
     if (explicit !== undefined)
         return explicit;
@@ -832,7 +1028,7 @@ async function logout() {
 // Unlike the login stage inside `install`, this command fails loud on
 // timeout/error — it's the explicit retry path.
 async function login(args) {
-    const provider = args.providerArg === "github" ? "github" : "google";
+    const provider = args.providerArg ?? args.forceReloginProvider ?? "google";
     const label = provider === "github" ? "GitHub" : "Google";
     ui.heading(`Sign in to ${label}`);
     // --force-relogin wipes this provider's cookies (via forceOpen below),
@@ -883,16 +1079,15 @@ function printHelp() {
     console.warn(`${chalk.bold("Commands")}`);
     console.warn(`  ${ui.code("connect")}                       set up this machine (default)`);
     console.warn(`  ${ui.code("login --provider=<p>")}          add a Google or GitHub session`);
+    console.warn(`  ${ui.code("settings")}                      edit registry, OTP, and proxy choices`);
     console.warn(`  ${ui.code("logout")}                        clear the local session`);
     console.warn("");
     console.warn(`${chalk.bold("Flags for connect")}`);
     console.warn(`  --target=<${Object.keys(AGENTS).join("|")}>`);
-    console.warn(`  --skip-secondary             don't prompt for the second provider`);
-    console.warn(`  --skip-login                 don't launch a browser (CI mode)`);
-    console.warn(`  --force-relogin              switch the bound account`);
+    console.warn(`  --skip-browser               don't launch a browser (CI mode)`);
+    console.warn(`  --force-relogin[=google|github] switch the bound account or one provider`);
     console.warn(`  --proxy-url=<url>            bake a residential proxy into the bot env`);
-    console.warn(`  --registry-url=<url>         use a non-default skill registry`);
-    console.warn(`  --no-registry                disable the Tier-2 router entirely`);
+    console.warn(`  --no-registry                disable managed registry participation`);
     console.warn(`  --no-interactive             skip the TUI picker (use flag defaults only)`);
     console.warn("");
     console.warn(`${chalk.bold("Example")}`);
@@ -912,6 +1107,9 @@ async function pollForClaim(apiBase, setupCode, intervalMsOrOpts = {}, timeoutMs
             return {
                 token: status.agent_session_token,
                 account_id: status.account_id ?? "",
+                ...(status.install_preferences !== undefined
+                    ? { preferences: status.install_preferences }
+                    : {}),
             };
         }
         if (status.status === "expired")
@@ -945,7 +1143,5 @@ function printAsnWarning(asn) {
             return;
     }
 }
-// Back-compat alias: external imports of `install` keep working at the module
-// level. The CLI command got renamed; the function is the same.
-export { connect, connect as install, logout, login, parseArgs, pollForClaim, printAsnWarning, resolveServerLaunch, };
+export { connect, logout, login, parseArgs, pollForClaim, printAsnWarning, resolveCopiedNpxServerLaunch, resolveServerLaunch, };
 //# sourceMappingURL=cli.js.map