@songsid/agend 2.3.2-beta.4 → 2.3.2-beta.5

package/dist/fleet-manager.d.ts

@@ -85,6 +85,7 @@ import { type CrossInstanceRecord, type XmsgVisibility } from "./search/search-d
 import { WebSettingsTools } from "./web-settings-tools.js";
 import { type Delegation, type TrafficItem } from "./fleet-traffic.js";
 import { WebBackendLogins, type SignInTarget } from "./web-backend-login.js";
+import { BrowserBackendSignIns } from "./browser-backend-signins.js";
 import { type RawConfigPatch } from "./settings-api.js";
 import { type AgentEndpointContext } from "./agent-endpoint.js";
 import { ClassicChannelManager } from "./classic-channel-manager.js";
@@ -246,6 +247,7 @@ export declare const CLI_ENV_PROBE_DEADLINE_MS = 16000;
  * started ten CLIs together, saturated the CPU, and healthy starts then missed
  * their startup budget — which used to cost the user their conversation. Cores
  * bound how many can actually make progress; memory bounds how many fit.
+ * `cores` is what this process may use (cpuset and cgroup quota, #749), not the host's count.
  */
 export declare function deriveSpawnConcurrency(freeMemMB: number, cores: number): number;
 /** #2499 review: one line of Settings → Guests' Recent changes (guestOverview), from the event log. */
@@ -454,6 +456,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private pendingBackendSelects;
     /** nonce → pending button prompt (hang restart, interactive assist, clean-exit restart). */
     private pendingNonceButtons;
+    /** #2598 B2: the kiro moves waiting on a fleet admin's Confirm in General, by prompt nonce. */
+    private pendingKiroMigrations;
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
     private needsYou;
     /** When the fleet first saw an instance crashed, for its "Needs you" age; cleared when it is not. */
@@ -764,6 +768,21 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     /** Exact configured effect owners; this does not depend on prompt location. */
     private settingsChatAuthority;
     private promptSettingsChange;
+    private kiroMigrateDeps;
+    /**
+     * #2598 B2, migrate_kiro_instance: judge the move, then ask in General for a fleet admin's Confirm. Nothing changes
+     * here; the move runs on the Confirm (handleKiroMigrateCallback), judged again then.
+     */
+    requestKiroMigration(name: string, startFresh: boolean): Promise<{
+        ok: true;
+        text: string;
+        classic_conversation: string | null;
+    } | {
+        ok: false;
+        error: string;
+    }>;
+    /** A fleet admin's Confirm or Cancel on a kiro move. Any fleet admin (the default nonce authorization), in General. */
+    private handleKiroMigrateCallback;
     private handleSettingsChangeCallback;
     startSettingsConfirmationControl(): Promise<void>;
     private get webToken();
@@ -2410,6 +2429,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * non-identity instance leaves are canonicalized to inheritance afterward.
      */
     saveFleetConfig(explicitPatches?: RawConfigPatch[]): void;
+    /** A permission tightening is effective when its save returns, independently of the later apply job or IPC. */
+    private refreshSavedDashboardPermissions;
     /** Why the config written to `candidate` must not replace fleet.yaml, or null: it does not load, or it adds errors. */
     private savedFleetConfigProblem;
     /**
@@ -2890,6 +2911,8 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      * without one); codex "unrecorded" (its rollouts don't say which login wrote them).
      */
     private usageProfileOf;
+    /** #2122 §10: a Kiro instance with a credential profile writes its classic store in that profile's home. */
+    private kiroDbPathOf;
     /** #2122: the fleet's day boundary zone — defaults.scheduler.default_timezone, else this host's. */
     usageZone(): string;
     /**
@@ -3370,6 +3393,13 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
      */
     private readonly loginWindow;
     private get webLogin();
+    private browserBackendSignInsInstance;
+    private structuredLoginCleanupFailed;
+    private readonly pendingBackendSince;
+    private browserSignInOwnerCurrent;
+    /** #2599: default-account controls share the exact writer reservation with chat/profile/install. */
+    get browserBackendSignIns(): BrowserBackendSignIns;
+    private needsYouBackendSignIns;
     /** #2233: sign-ins started from the web dashboard (local admin sessions), on the same controller as chat's. */
     private webBackendLoginsInstance;
     get webBackendLogins(): WebBackendLogins;
@@ -3663,6 +3693,11 @@ export declare class FleetManager implements FleetContext, LifecycleContext, Arc
     private cliEnvPath;
     /** Read the cached CLI env for a backend (a credential profile's own, when given), or null if missing/stale/unparseable. */
     private readCliEnv;
+    /**
+     * #2122 §10: the version the CLI probe last recorded for a backend — its cache file read whatever its age (the usage
+     * reader's version gate needs the last known version, not a fresh one); null when none was recorded. Never a probe.
+     */
+    private lastRecordedCliVersion;
     /** Return cached CLI versions immediately. Refresh is started after /sysinfo is sent. */
     getBackendCliVersionSnapshot(): BackendCliVersionSnapshot;
     /** Called only after the user-visible sysinfo send/respond has settled. */

package/dist/fleet-manager.js

@@ -31,13 +31,16 @@ import { ProfileControlServer } from "./profile-control.js";
 import { existsSync, readFileSync, mkdirSync, writeFileSync, unlinkSync, rmSync, readdirSync, renameSync, copyFileSync, chmodSync, statSync, accessSync, realpathSync, lstatSync, constants as fsConstants, closeSync } from "node:fs";
 import { atomicWriteFileSync } from "./atomic-write.js";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
-import { freemem, totalmem, cpus, homedir } from "node:os";
+import { freemem, totalmem, homedir } from "node:os";
+import { effectiveCpuCount } from "./cpu-quota.js";
 import { createServer } from "node:http";
 import { Worker } from "node:worker_threads";
 import { ProbeWorkerPool } from "./probe-worker-pool.js";
 import { join, dirname, basename, delimiter, isAbsolute, relative, resolve as resolvePath } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isDeepStrictEqual } from "node:util";
 import { getAgendHome, ensureWorkspaceGit } from "./paths.js";
+import { applyKiroMigration, kiroMigrationPrompt, planKiroMigration } from "./kiro-migrate.js";
 import { fleetLabel } from "./fleet-label.js";
 import { beginFullRestartProgress as persistFullRestartProgress, beginUpdateProgress as persistUpdateProgress, clearUpdateMarker, isUpdateInProgress, readUpdateProgress, sameUpdateMarker, setUpdateProgressStage, updateMarkerIdentity, updateProgressOperation, updateReceiptOf, } from "./update-marker.js";
 import { formatUpdateProgress } from "./update-progress.js";
@@ -56,7 +59,7 @@ const __dirname = dirname(__filename);
 const DEFAULT_OPEN_ACCESS = { mode: "open", allowed_users: [], max_pending_codes: 0, code_expiry_minutes: 0 };
 import { STATUS_EMOJI_CONFIG_KEYS, STATUS_EMOJI_KEYS, STATUS_EMOJI_SUGGESTIONS, TELEGRAM_REACTION_EMOJIS, builtinStatusEmojis, customEmojiValue, emojiImageUrl, normalizeEmoji, previewStatusEmojis, reactionForm, reactionMatchKey, resolveStatusEmojis, statusAvoidList, statusEmojiProblem, statusMatchKey, statusMatchKeys, textForm, } from "./status-emojis.js";
 import { isProbeableRouteTarget } from "./fleet-context.js";
-import { getEffectiveInstanceDefaults, loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG } from "./config.js";
+import { getEffectiveInstanceDefaults, loadFleetConfig, loadRawFleetConfig, DEFAULT_COST_GUARD, DEFAULT_DAILY_SUMMARY, DEFAULT_INSTANCE_CONFIG, autoGeneralInstanceConfig } from "./config.js";
 import { EventLog } from "./event-log.js";
 import { binaryProbe } from "./binary-probe.js";
 import { AVAILABILITY_STALE_MS, BackendAvailabilityStore, hostAvailabilityProbes } from "./backend-availability.js";
@@ -193,7 +196,7 @@ import { discordGeneralChannelId } from "./discord-general.js";
 import { parseEnvText } from "./env-file.js";
 import { isDisallowedIntentsError, isRejectedTokenError } from "./discord-permissions.js";
 import { filterUsageProviders, formatDiscordUsageActivity, getUsageSnapshot, handleUsageRequest, isUsagePath, usageProviderIdForBackend } from "./usage/usage-api.js";
-import { LOGIN_FLOWS, LOGIN_BACKEND_ALIASES } from "./login-flows.js";
+import { LOGIN_FLOWS, checkAuthStatus, LOGIN_BACKEND_ALIASES } from "./login-flows.js";
 import { LoginSession } from "./login-manager.js";
 import { runOnLoginShell } from "./login-shell.js";
 import { tightenInstanceDirs } from "./private-dir.js";
@@ -213,6 +216,10 @@ import { admitProfileLogin, LoginController, LOGIN_TOKEN_RESEND_PREFIX, POST_LOG
 import { WebBackendLogins, dashboardSignInSupported } from "./web-backend-login.js";
 import { runBeforeDeadline } from "./deadline.js";
 import { LoginWindowLock } from "./login-window-lock.js";
+import { BrowserBackendSignIns } from "./browser-backend-signins.js";
+import { createStructuredSignInTransport } from "./structured-signin-transport.js";
+import { ONBOARDING_BACKENDS, readPendingBackendSignIns } from "./backend-signin-pending.js";
+import { structuredSignInSupported } from "./structured-signin.js";
 import { handleSettingsRequest } from "./settings-api.js";
 import { setLocale, detectLocale, getLocale, t } from "./locale.js";
 import { recentChatContext } from "./log-tail.js";
@@ -276,6 +283,7 @@ import { PROVIDER_SECRET_SPECS, PUBLIC_TUNNEL_SECRET_SPEC, providerSecretSpec, p
 /** A self-restart is a whole service restart; 120s is the apply budget, not this. */
 const SELF_RESTART_DEADLINE_MS = 300_000;
 import { APPLY_FLEET_TARGET, ApplyJobStore, viewOf, } from "./apply-job.js";
+import { kiroHome } from "./backend/kiro-kas-store.js";
 import { CHAT_PROFILE_LOGIN_BACKENDS, credentialHomeSpec, credentialProfileHome, credentialProfileLogin, credentialProfileLoginCommand, credentialProfileStoreHome, credentialSwitchCarriesConversation, credentialSwitchStartsFresh, instanceCredentialProfile } from "./backend/credential-profile.js";
 import { carryClaudeConversation } from "./backend/claude-carry.js";
 import { mergeBackendOptions, profileKey, profileName, profileOf } from "./classic-bindings.js";
@@ -473,6 +481,10 @@ const OOM_RETRY_CALLBACK_PREFIX = "oom-retry:";
 const NEEDS_PAUSE_TTL_MS = 10_000;
 const HANG_CALLBACK_PREFIX = "hang:";
 const CLEAR_CONFIRM_CALLBACK_PREFIX = "clear-confirm:";
+/** #2598 B2: a kiro classic → TUI move's Confirm in General. "kiro-migrate:" (13) + 32 hex + ":confirm" (8) = 53 bytes. */
+const KIRO_MIGRATE_CALLBACK_PREFIX = "kiro-migrate:";
+/** Long enough for an admin to read the prompt; the move is judged again on the click. */
+const KIRO_MIGRATE_TIMEOUT_MS = 10 * 60_000;
 /**
  * The prompts the web dashboard also offers: the ones about an instance's own health, which a dashboard
  * user — holding the full-fleet web credential — may answer exactly as a fleet admin on the platform may.
@@ -568,6 +580,7 @@ export const CLI_ENV_PROBE_DEADLINE_MS = 16_000;
  * started ten CLIs together, saturated the CPU, and healthy starts then missed
  * their startup budget — which used to cost the user their conversation. Cores
  * bound how many can actually make progress; memory bounds how many fit.
+ * `cores` is what this process may use (cpuset and cgroup quota, #749), not the host's count.
  */
 export function deriveSpawnConcurrency(freeMemMB, cores) {
     const byMemory = Math.floor(freeMemMB / 300);
@@ -885,6 +898,8 @@ export class FleetManager {
     pendingBackendSelects = new Map();
     /** nonce → pending button prompt (hang restart, interactive assist, clean-exit restart). */
     pendingNonceButtons = new Map();
+    /** #2598 B2: the kiro moves waiting on a fleet admin's Confirm in General, by prompt nonce. */
+    pendingKiroMigrations = new Map();
     /** #1386 "Needs you": the list, its live chat messages and Acknowledge. Started with the fleet (finishStartup). */
     needsYou = null;
     /** When the fleet first saw an instance crashed, for its "Needs you" age; cleared when it is not. */
@@ -1723,6 +1738,74 @@ export class FleetManager {
         // No platform confirmation was reachable. Host inspection is still required.
         this.logger.info({ id: view.id }, "Settings change requires local `agend settings confirm <id>`");
     }
+    kiroMigrateDeps() {
+        return {
+            agendHome: getAgendHome(),
+            fleetConfig: () => this.fleetConfig,
+            saveFleetConfig: () => this.saveFleetConfig(),
+            status: name => this.getInstanceStatus(name),
+            restart: name => this.restartSingleInstance(name, { explicit: true }),
+        };
+    }
+    /**
+     * #2598 B2, migrate_kiro_instance: judge the move, then ask in General for a fleet admin's Confirm. Nothing changes
+     * here; the move runs on the Confirm (handleKiroMigrateCallback), judged again then.
+     */
+    async requestKiroMigration(name, startFresh) {
+        const judged = planKiroMigration(this.kiroMigrateDeps(), name, startFresh);
+        if (!judged.ok)
+            return judged;
+        const general = this.findGeneralInstance();
+        const adapterId = general ? this.getInstanceAdapterId(general) : undefined;
+        const adapter = general ? this.getAdapterForInstance(general) : undefined;
+        const chatId = general ? this.getGroupIdForInstance(general) : undefined;
+        const topic = general ? String(this.fleetConfig?.instances[general]?.topic_id ?? "") : "";
+        if (!general || !adapterId || !adapter || !chatId)
+            return { ok: false, error: t("kiro_migrate.no_general") };
+        const { plan } = judged;
+        try {
+            const nonce = await this.postNonceButtonPromptOrThrow({
+                prefix: KIRO_MIGRATE_CALLBACK_PREFIX, alertType: "clear_confirm", instanceName: name, adapter, adapterId, chatId,
+                ...(topic ? { threadId: topic } : {}),
+                message: kiroMigrationPrompt(plan, this.getInstanceStatus(name) === "running"),
+                choices: [{ action: "confirm", label: t("kiro_migrate.confirm_button") }, { action: "cancel", label: t("kiro_migrate.cancel_button") }],
+                expiredText: t("kiro_migrate.expired", name),
+                timeoutMs: KIRO_MIGRATE_TIMEOUT_MS,
+            });
+            this.pendingKiroMigrations.set(nonce, plan);
+            const expiry = setTimeout(() => this.pendingKiroMigrations.delete(nonce), KIRO_MIGRATE_TIMEOUT_MS + 60_000);
+            expiry.unref?.();
+        }
+        catch (err) {
+            return { ok: false, error: `${t("kiro_migrate.no_general")} (${err.message})` };
+        }
+        return { ok: true, text: t("kiro_migrate.requested"), classic_conversation: plan.classicId };
+    }
+    /** A fleet admin's Confirm or Cancel on a kiro move. Any fleet admin (the default nonce authorization), in General. */
+    async handleKiroMigrateCallback(data, adapterId, adapter) {
+        const claimed = this.consumeNonceCallback(KIRO_MIGRATE_CALLBACK_PREFIX, /^kiro-migrate:([0-9a-f]{32}):(confirm|cancel)$/, data, adapterId, adapter);
+        if (claimed === null)
+            return false;
+        if (claimed === "consumed")
+            return true;
+        const { entry, action } = claimed;
+        const nonce = data.callbackData.slice(KIRO_MIGRATE_CALLBACK_PREFIX.length, KIRO_MIGRATE_CALLBACK_PREFIX.length + 32);
+        const plan = this.pendingKiroMigrations.get(nonce);
+        this.pendingKiroMigrations.delete(nonce);
+        const messageId = entry.messageId ?? data.messageId;
+        if (action === "cancel" || !plan) {
+            await this.retireNonceButtons(entry, messageId, t(plan ? "kiro_migrate.cancelled" : "kiro_migrate.expired", entry.instanceName));
+            return true;
+        }
+        this.eventLog?.insert(plan.name, "kiro_migrate", { classicId: plan.classicId, userId: data.userId });
+        await this.retireNonceButtons(entry, messageId, t("kiro_migrate.applying", plan.name));
+        const outcome = await applyKiroMigration(this.kiroMigrateDeps(), plan);
+        this.logger.info({ name: plan.name, ok: outcome.ok, classicId: plan.classicId }, "kiro classic → TUI move");
+        this.notifyFleetError(outcome.text);
+        if (outcome.ok)
+            this.notifyInstanceTopic(plan.name, outcome.text);
+        return true;
+    }
     async handleSettingsChangeCallback(data, adapterId, adapter) {
         const result = this.consumeNonceCallback("settings-confirm:", /^settings-confirm:([0-9a-f]{32}):(confirm|reject)$/, data, adapterId, adapter, undefined, (userId, entry) => entry.confirmationAdmin?.(userId) === true);
         if (!result)
@@ -2576,7 +2659,7 @@ export class FleetManager {
         const explicit = this.fleetConfig?.defaults?.startup?.concurrency;
         if (explicit != null)
             return Math.max(1, Math.min(20, explicit));
-        return deriveSpawnConcurrency(Math.round(freemem() / (1024 * 1024)), cpus().length);
+        return deriveSpawnConcurrency(Math.round(freemem() / (1024 * 1024)), effectiveCpuCount());
     }
     /** #1685: "elevated" or "critical" while host memory pressure slows or holds new agents; otherwise null (an
      *  unknown macOS reading — the advisory case — is unknown, so null too). */
@@ -7774,7 +7857,8 @@ export class FleetManager {
         }
     }
     async startAllWithinDeadline(configPath, deadline) {
-        this.loginWindow.reopen(); // a stopAll → startAll restart must accept login windows again
+        if (!this.structuredLoginCleanupFailed)
+            this.loginWindow.reopen(); // a stopAll → startAll restart must accept login windows again
         this.loginController?.reopen();
         const startupStartedAt = Date.now();
         FleetManager.signalTarget = this;
@@ -8035,12 +8119,7 @@ export class FleetManager {
             mkdirSync(generalDir, { recursive: true, mode: 0o700 });
             const backendName = fleet.defaults.backend ?? "claude-code";
             this.ensureGeneralInstructions(generalDir, backendName, name);
-            fleet.instances[name] = {
-                ...DEFAULT_INSTANCE_CONFIG,
-                working_directory: generalDir,
-                general_topic: true,
-                channel_id: need.adapterId,
-            };
+            fleet.instances[name] = autoGeneralInstanceConfig(fleet.defaults, generalDir, need.adapterId); // #2598: its kiro_ui is the fleet's
             generalsCreated = true;
         }
         if (generalsCreated)
@@ -12251,9 +12330,46 @@ export class FleetManager {
             },
         });
         this.rawFleetConfig = loadRawFleetConfig(this.configPath);
+        // The instance map is defaults-expanded. A defaults edit changes that view even when it writes no instance
+        // leaves. Re-resolve from the committed YAML so inherited values cannot become stale overrides on the next save.
+        // Keep the FleetConfig object itself: Settings and other request contexts hold it.
+        const resolvedInstances = loadFleetConfig(this.configPath).instances;
+        for (const [name, resolved] of Object.entries(resolvedInstances)) {
+            const current = this.fleetConfig.instances[name];
+            if (!current) {
+                this.fleetConfig.instances[name] = resolved;
+                continue;
+            }
+            // Lifecycle rollback fences hold these object identities across save. Refresh their values, not their owner.
+            for (const key of Object.keys(current))
+                if (!Object.hasOwn(resolved, key))
+                    delete current[key];
+            Object.assign(current, resolved);
+        }
         this.savedFleetConfigSnapshot = structuredClone(this.fleetConfig);
+        this.refreshSavedDashboardPermissions();
         this.logger.info({ path: this.configPath, strippedDefaults: redundantPaths.length }, "Saved fleet config (lossless patch)");
     }
+    /** A permission tightening is effective when its save returns, independently of the later apply job or IPC. */
+    refreshSavedDashboardPermissions() {
+        if (!this.fleetConfig)
+            return;
+        const classicNames = new Set(this.classicChannels?.getAll().map(ch => ch.instanceName) ?? []);
+        for (const [name, daemon] of this.daemons) {
+            const next = this.fleetConfig.instances[name] ?? (classicNames.has(name) ? getEffectiveInstanceDefaults(this.fleetConfig.defaults) : undefined);
+            const previous = daemon.getConfigSnapshot?.();
+            if (!next || !previous)
+                continue;
+            if (isDeepStrictEqual(previous.dashboard, next.dashboard) && previous.office_access === next.office_access)
+                continue;
+            // Only permissions are adopted here. Cold fields retain the live daemon's old snapshot, so reconcile still
+            // detects that they require a restart. MCP menus also watch the raw file; this updates the next spawn's env.
+            daemon.applyConfigUpdate({ dashboard: next.dashboard ?? null, office_access: next.office_access ?? null });
+            if (taskBoardSwitchedOn(previous.dashboard, next.dashboard)) {
+                this.admitTaskBoardNotice(name, TASK_BOARD_ON_NOTICE, `task-board-on:${name}:${Date.now()}`);
+            }
+        }
+    }
     /** Why the config written to `candidate` must not replace fleet.yaml, or null: it does not load, or it adds errors. */
     savedFleetConfigProblem(candidate) {
         let after;
@@ -14357,6 +14473,8 @@ export class FleetManager {
             return true;
         if (await this.handleSettingsChangeCallback(data, adapterId, adapter))
             return true;
+        if (await this.handleKiroMigrateCallback(data, adapterId, adapter))
+            return true;
         if (await this.handleDashboardCallback(data, adapterId, adapter))
             return true;
         if (await this.handleClassicApproval(data, adapterId, adapter))
@@ -14477,6 +14595,7 @@ export class FleetManager {
         const fleet = Object.entries(this.fleetConfig?.instances ?? {}).map(([name, cfg]) => ({
             name, backend: this.backendNameOf(name), workingDirectory: cfg.working_directory, ledgerPath: join(this.getInstanceDir(name), "cache-ledger.json"),
             claudeConfigDir: this.claudeConfigDirOf(name), profile: this.usageProfileOf(name, this.backendNameOf(name)),
+            kiroDbPath: this.kiroDbPathOf(name, this.backendNameOf(name)),
         }));
         const taken = new Set(fleet.map(i => i.name));
         const classic = (this.classicChannels?.getAll() ?? []).filter(ch => !taken.has(ch.instanceName)).map(ch => ({
@@ -14486,6 +14605,7 @@ export class FleetManager {
             ledgerPath: join(this.getInstanceDir(ch.instanceName), "cache-ledger.json"),
             claudeConfigDir: this.claudeConfigDirOf(ch.instanceName),
             profile: this.usageProfileOf(ch.instanceName, this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code"),
+            kiroDbPath: this.kiroDbPathOf(ch.instanceName, this.classicChannels?.getBackendByInstance(ch.instanceName, this.fleetConfig?.defaults?.backend) ?? this.fleetConfig?.defaults?.backend ?? "claude-code"),
         }));
         return [...fleet, ...new Map(classic.map(c => [c.name, c])).values()];
     }
@@ -14506,8 +14626,19 @@ export class FleetManager {
             return this.credentialProfileOf(name, "claude-code") ?? "default";
         if (backend === "codex")
             return "unrecorded";
+        if (backend === "kiro-cli")
+            return this.credentialProfileOf(name, "kiro-cli") ?? "default";
+        if (backend === "grok" || backend === "muse" || backend === "opencode" || backend === "antigravity")
+            return "default";
         return undefined;
     }
+    /** #2122 §10: a Kiro instance with a credential profile writes its classic store in that profile's home. */
+    kiroDbPathOf(name, backend) {
+        if (backend !== "kiro-cli")
+            return undefined;
+        const profile = this.credentialProfileOf(name, "kiro-cli");
+        return profile ? join(credentialProfileStoreHome(getAgendHome(), "kiro-cli", profile), "data.sqlite3") : undefined;
+    }
     /** #2122: the fleet's day boundary zone — defaults.scheduler.default_timezone, else this host's. */
     usageZone() {
         return this.fleetConfig?.defaults?.scheduler?.default_timezone?.trim() || Intl.DateTimeFormat().resolvedOptions().timeZone || "UTC";
@@ -14550,6 +14681,19 @@ export class FleetManager {
             rolloutsUnreadable: root => sharedRolloutIndex(root).unreadable,
             metaPath: join(this.dataDir, "cache-codex-rollouts.json"),
             zone: () => this.usageZone(),
+            // #2122 §10: Kiro's shared classic store (XDG_DATA_HOME, as kiro-cli resolves it) and its KIRO_HOME.
+            kiroDbPath: () => join(process.env.XDG_DATA_HOME?.trim() || join(homedir(), ".local", "share"), "kiro-cli", "data.sqlite3"),
+            kiroHome: () => kiroHome(),
+            // #2122 §10 step 3: grok keeps its sessions under ~/.grok (grok.ts reads them there too).
+            grokSessionsDir: () => join(homedir(), ".grok", "sessions"),
+            // #2122 §10 step 4: muse keeps sessions under $XDG_DATA_HOME/muse (else ~/.local/share/muse), as muse.ts reads them.
+            // #2122 §10 step 5: OpenCode's database, under XDG_DATA_HOME as opencode resolves it.
+            // #2122 §10 step 6: agy's conversations, under ~/.gemini as the antigravity backend reads its settings.
+            antigravityDir: () => join(homedir(), ".gemini", "antigravity-cli", "conversations"),
+            // The version AgEnD's CLI probe last recorded for agy: its cache file, whatever its age (never runs agy).
+            antigravityVersion: () => this.lastRecordedCliVersion("antigravity"),
+            opencodeDbPath: () => join(process.env.XDG_DATA_HOME?.trim() || join(homedir(), ".local", "share"), "opencode", "opencode.db"),
+            museSessionsDir: () => join(process.env.XDG_DATA_HOME?.trim() || join(homedir(), ".local", "share"), "muse", "sessions"),
             log: (level, msg, extra) => this.logger[level](extra ?? {}, msg),
         });
     }
@@ -14670,6 +14814,7 @@ export class FleetManager {
                 return this.deliveryOutbox.acknowledge(deliveryId, by);
             },
             tasks: () => this.needsYouTaskItems(),
+            backendSignIns: () => this.needsYouBackendSignIns(),
             taskAction: action => this.taskActionFromChat(action),
             settings: () => ({
                 liveMessage: this.fleetConfig?.needs_you?.live_message !== false,
@@ -16685,6 +16830,55 @@ export class FleetManager {
         }
         return this.loginController;
     }
+    browserBackendSignInsInstance = null;
+    structuredLoginCleanupFailed = false;
+    pendingBackendSince = new Map();
+    browserSignInOwnerCurrent(owner) {
+        const record = owner;
+        return !this.shuttingDown && typeof record.handle === "string" && this.webSessions?.findByHandle(record.handle) === owner
+            && this.isLocalAdminSession(record.handle);
+    }
+    /** #2599: default-account controls share the exact writer reservation with chat/profile/install. */
+    get browserBackendSignIns() {
+        return this.browserBackendSignInsInstance ??= new BrowserBackendSignIns({
+            dataDir: this.dataDir, lock: this.loginWindow,
+            current: owner => this.browserSignInOwnerCurrent(owner),
+            installed: async () => ONBOARDING_BACKENDS.filter(backend => this.isCliInstalled(backend)),
+            checkAuth: backend => checkAuthStatus(LOGIN_FLOWS[backend].authCheck),
+            checkConsoleAuth: () => checkAuthStatus(LOGIN_FLOWS.antigravity.authCheck),
+            transport: () => createStructuredSignInTransport(),
+            changed: (event, owner, launched) => {
+                try {
+                    this.eventLog?.insert("login", "browser_backend_signin", event);
+                }
+                catch { /* safe metadata only */ }
+                broadcastSseEvent(this.sseClients, "backend_login", {}, err => this.logger.debug({ err }, "backend_login event failed"));
+                this.needsYou?.poke();
+                if (!this.browserSignInOwnerCurrent(owner))
+                    return;
+                if (event.phase === "starting") {
+                    const record = owner;
+                    this.notifyFleetError(t("login.web_dashboard_notice", event.backend, record.label, record.handle.slice(0, 8)));
+                }
+                if (event.phase === "done") {
+                    void this.backendAvailability.refresh([event.backend], { force: true }).catch(() => { });
+                    if (launched)
+                        void this.recoverBackendInstances(event.backend, undefined, null).catch(() => this.logger.warn({ backend: event.backend }, "Post sign-in recovery failed"));
+                }
+            },
+        });
+    }
+    needsYouBackendSignIns() {
+        const pending = readPendingBackendSignIns(this.dataDir).pending;
+        for (const backend of this.pendingBackendSince?.keys() ?? [])
+            if (!pending.includes(backend))
+                this.pendingBackendSince.delete(backend);
+        return pending.map(backend => {
+            if (!this.pendingBackendSince.has(backend))
+                this.pendingBackendSince.set(backend, Date.now());
+            return { backend, since: this.pendingBackendSince.get(backend), browser: structuredSignInSupported(backend) };
+        });
+    }
     /** #2233: sign-ins started from the web dashboard (local admin sessions), on the same controller as chat's. */
     webBackendLoginsInstance = null;
     get webBackendLogins() {
@@ -17037,6 +17231,14 @@ export class FleetManager {
         // "cancelled" is the detail both legacy onDone handlers keep quiet about —
         // a stopping fleet must not announce "login failed — fleet shutdown".
         await Promise.all([
+            bounded(this.browserBackendSignInsInstance?.close().then(confirmed => {
+                if (confirmed)
+                    this.browserBackendSignInsInstance = null;
+                else {
+                    this.structuredLoginCleanupFailed = true;
+                    this.logger.error("Structured login cleanup failed; sign-in admission remains closed until the host is restarted.");
+                }
+            }), "browser-controls"),
             bounded(this.loginController?.shutdown(), "web-login"),
             bounded(this.activeInstall?.session.cancel("cancelled"), "install"),
         ]);
@@ -17053,6 +17255,13 @@ export class FleetManager {
             this.installHandoff = null;
             return t("login.cancelled", backend);
         }
+        const browserLogin = this.browserBackendSignInsInstance, browserBackend = browserLogin?.activeBackend;
+        if (browserLogin && browserBackend) {
+            const confirmed = await browserLogin.close();
+            if (confirmed)
+                this.browserBackendSignInsInstance = null;
+            return confirmed ? t("login.cancelled", browserBackend) : t("login.browser_cleanup_failed");
+        }
         if (this.loginController?.isActive())
             return this.loginController.cancel();
         return t("login.no_session");
@@ -18564,6 +18773,19 @@ Plus the operational skills (fleet-health, instance-lifecycle, scheduling, sessi
         catch { /* missing / stale / corrupt */ }
         return null;
     }
+    /**
+     * #2122 §10: the version the CLI probe last recorded for a backend — its cache file read whatever its age (the usage
+     * reader's version gate needs the last known version, not a fresh one); null when none was recorded. Never a probe.
+     */
+    lastRecordedCliVersion(backend) {
+        try {
+            const v = JSON.parse(readFileSync(this.cliEnvPath(backend), "utf-8")).version;
+            return typeof v === "string" && v.trim() ? v.trim() : null;
+        }
+        catch {
+            return null;
+        }
+    }
     /** Return cached CLI versions immediately. Refresh is started after /sysinfo is sent. */
     getBackendCliVersionSnapshot() {
         const snapshot = {};