@modelprofile.com/authswitch 6.4.0 → 6.5.0

package/dist_ts/classes.codexmanaged.js

@@ -0,0 +1,343 @@
+import * as plugins from './plugins.js';
+import { commitinfo } from './00_commitinfo_data.js';
+const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+const isAlive = (child) => child.exitCode === null && child.signalCode === null;
+const wait = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+/** Same-user process inspection: a unique private --listen socket is the pre-PID crash identity. */
+export const findManagedCodexProcess = async (socketPath) => {
+    if (process.platform === 'win32')
+        throw new Error('Managed Codex Unix socket process inspection is unavailable on Windows.');
+    const output = await new Promise((resolve, reject) => {
+        plugins.childProcess.execFile('ps', ['-ww', '-u', String(process.getuid?.()), '-o', 'pid=,lstart=,args='], { timeout: 5_000, maxBuffer: 8 * 1024 * 1024, env: { ...process.env, LC_ALL: 'C' } }, (error, stdout) => error ? reject(new Error('Managed Codex process inspection failed.')) : resolve(stdout));
+    });
+    const marker = `app-server --listen unix://${socketPath}`;
+    const matches = [];
+    for (const line of output.split('\n')) {
+        const parts = line.trim().split(/\s+/);
+        if (parts.length < 8)
+            continue;
+        const pid = Number(parts[0]);
+        const date = Date.parse(parts.slice(1, 6).join(' '));
+        const args = parts.slice(6).join(' ');
+        if (Number.isSafeInteger(pid) && pid > 0 && Number.isFinite(date) && args.includes(marker)) {
+            matches.push({ pid, startedAt: new Date(date).toISOString() });
+        }
+    }
+    if (matches.length > 1)
+        throw new Error('Multiple managed Codex processes claim one private socket.');
+    return matches[0] ?? null;
+};
+/** Daemon-owned Codex app-server. Only access tokens, never refresh grants, enter Codex. */
+export class AuthSwitchManagedCodex {
+    options;
+    child;
+    childExited;
+    client;
+    runDirectory;
+    homeDirectory;
+    socketPath;
+    workspaceId;
+    grantedGeneration;
+    startPromise;
+    closePromise;
+    closed = false;
+    ready = false;
+    constructor(options) {
+        this.options = options;
+        if (!plugins.path.isAbsolute(options.runtimeDirectory) || !plugins.path.isAbsolute(options.workspaceDirectory)
+            || !plugins.path.isAbsolute(options.codexHomeDirectory)) {
+            throw new Error('Managed Codex requires absolute runtime, home and workspace directories.');
+        }
+    }
+    get isReady() { return this.ready && this.client?.state === 'connected' && !this.closed; }
+    environment() {
+        const picked = {};
+        for (const key of ['PATH', 'HOME', 'USER', 'LOGNAME', 'LANG', 'LC_ALL', 'TERM', 'TMPDIR', 'XDG_RUNTIME_DIR']) {
+            if (process.env[key] !== undefined)
+                picked[key] = process.env[key];
+        }
+        picked.CODEX_HOME = this.homeDirectory;
+        return picked;
+    }
+    async requireVersion() {
+        const executable = this.options.executable ?? 'codex';
+        const output = await new Promise((resolve, reject) => {
+            plugins.childProcess.execFile(executable, ['--version'], { timeout: 5_000, maxBuffer: 4096,
+                windowsHide: true, env: this.environment() }, (error, stdout) => {
+                if (error)
+                    reject(new Error('Managed Codex version probe failed.'));
+                else
+                    resolve(stdout.trim());
+            });
+        });
+        if (output !== 'codex-cli 0.155.1')
+            throw new Error('Managed Codex requires verified codex-cli 0.155.1.');
+    }
+    start() {
+        if (this.closed || this.startPromise)
+            throw new Error('Managed Codex can start only once.');
+        this.startPromise = this.performStart();
+        return this.startPromise;
+    }
+    async performStart() {
+        try {
+            const root = this.options.runtimeDirectory;
+            await plugins.fs.promises.mkdir(root, { recursive: true, mode: 0o700 });
+            const rootStat = await plugins.fs.promises.lstat(root);
+            if (!rootStat.isDirectory() || rootStat.isSymbolicLink() || rootStat.uid !== process.getuid?.()) {
+                throw new Error('Managed Codex runtime directory is not private.');
+            }
+            await plugins.fs.promises.chmod(root, 0o700);
+            this.runDirectory = await plugins.fs.promises.mkdtemp(plugins.path.join(root, 'codex-'));
+            await plugins.fs.promises.chmod(this.runDirectory, 0o700);
+            this.homeDirectory = this.options.codexHomeDirectory;
+            this.socketPath = plugins.path.join(this.runDirectory, 'app.sock');
+            if (Buffer.byteLength(this.socketPath, 'utf8') > 100)
+                throw new Error('Managed Codex socket path is too long.');
+            const homeStat = await plugins.fs.promises.lstat(this.homeDirectory);
+            if (!homeStat.isDirectory() || homeStat.isSymbolicLink() || homeStat.uid !== process.getuid?.()
+                || (homeStat.mode & 0o077) !== 0 || await plugins.fs.promises.realpath(this.homeDirectory) !== this.homeDirectory) {
+                throw new Error('Managed Codex home is not a private owned directory.');
+            }
+            try {
+                await plugins.fs.promises.lstat(plugins.path.join(this.homeDirectory, 'auth.json'));
+                throw new Error('Managed Codex home contains a native credential file.');
+            }
+            catch (error) {
+                if (!isRecord(error) || error.code !== 'ENOENT')
+                    throw error;
+            }
+            await this.requireVersion();
+            if (this.closed)
+                throw new Error('Managed Codex startup was cancelled.');
+            const initial = await this.options.broker.resolveAccess(this.options.bindingId, this.options.capability, 60_000);
+            if (this.closed)
+                throw new Error('Managed Codex startup was cancelled.');
+            this.workspaceId = initial.accountId;
+            this.grantedGeneration = initial.grantGeneration;
+            await this.options.onPreparedRun(this.socketPath);
+            if (this.closed)
+                throw new Error('Managed Codex startup was cancelled.');
+            const child = plugins.childProcess.spawn(this.options.executable ?? 'codex', [
+                'app-server', '--listen', `unix://${this.socketPath}`, '--strict-config',
+                '-c', 'cli_auth_credentials_store="ephemeral"',
+            ], { cwd: this.options.workspaceDirectory, env: this.environment(), shell: false,
+                detached: process.platform !== 'win32', stdio: 'ignore', windowsHide: true });
+            this.child = child;
+            this.childExited = new Promise(resolve => {
+                child.once('error', () => resolve());
+                child.once('exit', () => resolve());
+            });
+            if (!child.pid)
+                throw new Error('Managed Codex app-server process has no PID.');
+            let observed = null;
+            for (let attempt = 0; attempt < 20 && !observed; attempt++) {
+                observed = await findManagedCodexProcess(this.socketPath);
+                if (!observed)
+                    await wait(25);
+            }
+            if (!observed || observed.pid !== child.pid)
+                throw new Error('Managed Codex app-server process identity could not be verified.');
+            await this.options.onChildSpawned(observed.pid, observed.startedAt);
+            const deadline = Date.now() + 10_000;
+            while (true) {
+                if (this.closed)
+                    throw new Error('Managed Codex startup was cancelled.');
+                if (!isAlive(child))
+                    throw new Error('Managed Codex app-server exited before accepting connections.');
+                try {
+                    if ((await plugins.fs.promises.lstat(this.socketPath)).isSocket())
+                        break;
+                }
+                catch (error) {
+                    if (!isRecord(error) || error.code !== 'ENOENT')
+                        throw error;
+                }
+                if (Date.now() >= deadline)
+                    throw new Error('Managed Codex app-server socket startup timed out.');
+                await wait(25);
+            }
+            const client = new plugins.crossharness.CodexAppServerClient({
+                transport: { type: 'unix', socketPath: this.socketPath },
+                clientInfo: { name: 'authswitch', title: 'Authswitch', version: commitinfo.version },
+                experimentalApi: true, handshakeTimeoutMs: 5_000, initializeTimeoutMs: 5_000,
+                onNotification: notification => this.options.onNotification?.(notification),
+                onServerRequest: request => { void this.handleServerRequest(request); },
+                onClose: () => {
+                    const wasReady = this.ready;
+                    this.ready = false;
+                    if (wasReady && !this.closed)
+                        this.options.onUnavailable?.();
+                },
+            });
+            this.client = client;
+            await client.connect();
+            if (client.serverVersion !== '0.155.1')
+                throw new Error('Managed Codex app-server version changed.');
+            const login = await client.request('account/login/start', {
+                type: 'chatgptAuthTokens', accessToken: initial.accessToken, chatgptAccountId: initial.accountId,
+            }, 5_000);
+            if (!isRecord(login) || login.type !== 'chatgptAuthTokens') {
+                throw new Error('Managed Codex external-token login was not acknowledged.');
+            }
+            if (this.closed)
+                throw new Error('Managed Codex startup was cancelled.');
+            this.ready = true;
+        }
+        catch (error) {
+            try {
+                await this.close();
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], 'Managed Codex startup and cleanup failed.');
+            }
+            throw error;
+        }
+    }
+    async handleServerRequest(request) {
+        const client = this.client;
+        if (!client || this.closed || !this.ready)
+            return;
+        if (request.method !== 'account/chatgptAuthTokens/refresh') {
+            if (!this.options.onServerRequest) {
+                client.rejectRequest(request.id, -32601, 'Managed Codex request requires an owner handler.');
+                return;
+            }
+            try {
+                this.options.onServerRequest(request, {
+                    respond: result => client.respond(request.id, result),
+                    reject: (code, message) => client.rejectRequest(request.id, code, message),
+                });
+            }
+            catch {
+                client.rejectRequest(request.id, -32603, 'Managed Codex owner request failed.');
+            }
+            return;
+        }
+        const prior = this.grantedGeneration;
+        const workspaceId = this.workspaceId;
+        const params = request.params;
+        if (params.reason !== 'unauthorized' || !workspaceId || prior === undefined
+            || (params.previousAccountId !== undefined && params.previousAccountId !== null
+                && params.previousAccountId !== workspaceId)) {
+            client.rejectRequest(request.id, -32602, 'Managed Codex account identity is invalid.');
+            return;
+        }
+        try {
+            const refreshed = await this.options.broker.resolveAccess(this.options.bindingId, this.options.capability, 60_000, prior);
+            if (this.closed || request.signal.aborted)
+                return;
+            if (refreshed.accountId !== workspaceId || refreshed.grantGeneration <= prior) {
+                client.rejectRequest(request.id, -32603, 'Managed Codex account refresh did not advance.');
+                return;
+            }
+            this.grantedGeneration = refreshed.grantGeneration;
+            client.respond(request.id, { accessToken: refreshed.accessToken,
+                chatgptAccountId: refreshed.accountId, chatgptPlanType: null });
+        }
+        catch {
+            if (!request.signal.aborted)
+                client.rejectRequest(request.id, -32603, 'Managed Codex account needs reauthentication.');
+        }
+    }
+    /** The interactive CLI attaches to the owned app-server; the daemon remains its auth control peer. */
+    interactiveCommand() {
+        if (!this.isReady || !this.socketPath)
+            throw new Error('Managed Codex is unavailable.');
+        return { executable: this.options.executable ?? 'codex', args: ['--remote', `unix://${this.socketPath}`],
+            cwd: this.options.workspaceDirectory, env: this.environment() };
+    }
+    /** Native app-server thread/turn API for noninteractive consumers; notifications go to onNotification. */
+    async startThread(options) {
+        if (!this.isReady || !this.client || !options || !['never', 'on-request'].includes(options.approvalPolicy)
+            || (options.model !== undefined && (typeof options.model !== 'string' || options.model.length > 128))) {
+            throw new Error('Managed Codex thread request is unavailable or invalid.');
+        }
+        const started = await this.client.request('thread/start', {
+            cwd: this.options.workspaceDirectory, approvalPolicy: options.approvalPolicy,
+            ...(options.model ? { model: options.model } : {}),
+        }, 30_000, options.signal);
+        if (!isRecord(started) || !isRecord(started.thread) || typeof started.thread.id !== 'string') {
+            throw new Error('Managed Codex returned an invalid thread.');
+        }
+        return started.thread.id;
+    }
+    async resumeThread(threadId, options) {
+        if (!this.isReady || !this.client || typeof threadId !== 'string' || !threadId || threadId.length > 256
+            || !options || !['never', 'on-request'].includes(options.approvalPolicy)
+            || (options.model !== undefined && (typeof options.model !== 'string' || options.model.length > 128))) {
+            throw new Error('Managed Codex resume request is unavailable or invalid.');
+        }
+        const resumed = await this.client.request('thread/resume', { threadId,
+            cwd: this.options.workspaceDirectory, approvalPolicy: options.approvalPolicy,
+            ...(options.model ? { model: options.model } : {}),
+        }, 30_000, options.signal);
+        if (!isRecord(resumed) || !isRecord(resumed.thread) || resumed.thread.id !== threadId) {
+            throw new Error('Managed Codex could not resume the requested thread from its assigned home.');
+        }
+    }
+    async startTextTurn(text, options) {
+        if (!this.isReady || !this.client || typeof text !== 'string' || !text.trim() || text.length > 1_000_000
+            || !options || !['never', 'on-request'].includes(options.approvalPolicy)
+            || (options.model !== undefined && (typeof options.model !== 'string' || options.model.length > 128))
+            || (options.threadId !== undefined && (typeof options.threadId !== 'string' || options.threadId.length > 256))) {
+            throw new Error('Managed Codex turn request is unavailable or invalid.');
+        }
+        let threadId = options.threadId;
+        if (threadId) {
+            await this.resumeThread(threadId, options);
+        }
+        else {
+            threadId = await this.startThread(options);
+        }
+        const turn = await this.client.request('turn/start', { threadId,
+            input: [{ type: 'text', text, text_elements: [] }],
+            approvalPolicy: options.approvalPolicy,
+            ...(options.model ? { model: options.model } : {}),
+        }, 30_000, options.signal);
+        if (!isRecord(turn) || !isRecord(turn.turn) || typeof turn.turn.id !== 'string') {
+            throw new Error('Managed Codex returned an invalid turn.');
+        }
+        return { threadId, turnId: turn.turn.id };
+    }
+    close() {
+        if (this.closePromise)
+            return this.closePromise;
+        const wasReady = this.ready;
+        this.closed = true;
+        this.ready = false;
+        this.closePromise = this.performClose();
+        if (wasReady)
+            this.options.onUnavailable?.();
+        return this.closePromise;
+    }
+    async performClose() {
+        this.client?.close('Managed Codex stopped.');
+        const child = this.child;
+        if (child && isAlive(child) && child.pid) {
+            try {
+                process.kill(process.platform === 'win32' ? child.pid : -child.pid, 'SIGTERM');
+            }
+            catch (error) {
+                if (!isRecord(error) || error.code !== 'ESRCH')
+                    throw error;
+            }
+            await Promise.race([this.childExited, wait(3_000)]);
+            if (isAlive(child)) {
+                try {
+                    process.kill(process.platform === 'win32' ? child.pid : -child.pid, 'SIGKILL');
+                }
+                catch (error) {
+                    if (!isRecord(error) || error.code !== 'ESRCH')
+                        throw error;
+                }
+                await Promise.race([this.childExited, wait(3_000)]);
+            }
+            if (isAlive(child))
+                throw new Error('Managed Codex process did not stop.');
+        }
+        if (this.runDirectory)
+            await plugins.fs.promises.rm(this.runDirectory, { recursive: true, force: true });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.codexmanaged.js","sourceRoot":"","sources":["../ts/classes.codexmanaged.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AA6BrD,MAAM,QAAQ,GAAG,CAAC,KAAc,EAAoC,EAAE,CACpE,KAAK,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;AACvE,MAAM,OAAO,GAAG,CAAC,KAAwC,EAAW,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,IAAI,IAAI,KAAK,CAAC,UAAU,KAAK,IAAI,CAAC;AAC5H,MAAM,IAAI,GAAG,CAAC,EAAU,EAAiB,EAAE,CAAC,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AAE5F,oGAAoG;AACpG,MAAM,CAAC,MAAM,uBAAuB,GAAG,KAAK,EAAE,UAAkB,EAAsD,EAAE;IACtH,IAAI,OAAO,CAAC,QAAQ,KAAK,OAAO;QAAE,MAAM,IAAI,KAAK,CAAC,yEAAyE,CAAC,CAAC;IAC7H,MAAM,MAAM,GAAG,MAAM,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QAC3D,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,IAAI,EAAE,oBAAoB,CAAC,EACvG,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,EAAE,GAAG,EAAE,EAAE,GAAG,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,EAAE,EACpF,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,0CAA0C,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC;IAChH,CAAC,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,8BAA8B,UAAU,EAAE,CAAC;IAC1D,MAAM,OAAO,GAA8C,EAAE,CAAC;IAC9D,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACtC,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACvC,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC;YAAE,SAAS;QAC/B,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;QAC7B,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QACrD,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACtC,IAAI,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3F,OAAO,CAAC,IAAI,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QACjE,CAAC;IACH,CAAC;IACD,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC;QAAE,MAAM,IAAI,KAAK,CAAC,4DAA4D,CAAC,CAAC;IACtG,OAAO,OAAO,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC;AAC5B,CAAC,CAAC;AAEF,4FAA4F;AAC5F,MAAM,OAAO,sBAAsB;IAcJ;IAbrB,KAAK,CAAqC;IAC1C,WAAW,CAAiB;IAC5B,MAAM,CAA6C;IACnD,YAAY,CAAU;IACtB,aAAa,CAAU;IACvB,UAAU,CAAU;IACpB,WAAW,CAAU;IACrB,iBAAiB,CAAU;IAC3B,YAAY,CAAiB;IAC7B,YAAY,CAAiB;IAC7B,MAAM,GAAG,KAAK,CAAC;IACf,KAAK,GAAG,KAAK,CAAC;IAEtB,YAA6B,OAAuC;QAAvC,YAAO,GAAP,OAAO,CAAgC;QAClE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,kBAAkB,CAAC;eACzG,CAAC,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,kBAAkB,CAAC,EAAE,CAAC;YAC1D,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;QAC9F,CAAC;IACH,CAAC;IAED,IAAW,OAAO,KAAc,OAAO,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,MAAM,EAAE,KAAK,KAAK,WAAW,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC;IAElG,WAAW;QACjB,MAAM,MAAM,GAAsB,EAAE,CAAC;QACrC,KAAK,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,CAAC,EAAE,CAAC;YAC7G,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,SAAS;gBAAE,MAAM,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACrE,CAAC;QACD,MAAM,CAAC,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC;QACvC,OAAO,MAAM,CAAC;IAChB,CAAC;IAEO,KAAK,CAAC,cAAc;QAC1B,MAAM,UAAU,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC;QACtD,MAAM,MAAM,GAAG,MAAM,IAAI,OAAO,CAAS,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YAC3D,OAAO,CAAC,YAAY,CAAC,QAAQ,CAAC,UAAU,EAAE,CAAC,WAAW,CAAC,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI;gBACxF,WAAW,EAAE,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;gBAChE,IAAI,KAAK;oBAAE,MAAM,CAAC,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC,CAAC;;oBAC/D,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,CAAC;YAC9B,CAAC,CAAC,CAAC;QACL,CAAC,CAAC,CAAC;QACH,IAAI,MAAM,KAAK,mBAAmB;YAAE,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;IAC5G,CAAC;IAEM,KAAK;QACV,IAAI,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,YAAY;YAAE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;QAC5F,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACxC,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAEO,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC;YAC3C,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;YACxE,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YACvD,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,QAAQ,CAAC,cAAc,EAAE,IAAI,QAAQ,CAAC,GAAG,KAAK,OAAO,CAAC,MAAM,EAAE,EAAE,EAAE,CAAC;gBAChG,MAAM,IAAI,KAAK,CAAC,iDAAiD,CAAC,CAAC;YACrE,CAAC;YACD,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;YAC7C,IAAI,CAAC,YAAY,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC;YACzF,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC;YAC1D,IAAI,CAAC,aAAa,GAAG,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC;YACrD,IAAI,CAAC,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,YAAY,EAAE,UAAU,CAAC,CAAC;YACnE,IAAI,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,GAAG;gBAAE,MAAM,IAAI,KAAK,CAAC,wCAAwC,CAAC,CAAC;YAChH,MAAM,QAAQ,GAAG,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;YACrE,IAAI,CAAC,QAAQ,CAAC,WAAW,EAAE,IAAI,QAAQ,CAAC,cAAc,EAAE,IAAI,QAAQ,CAAC,GAAG,KAAK,OAAO,CAAC,MAAM,EAAE,EAAE;mBAC1F,CAAC,QAAQ,CAAC,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;gBACpH,MAAM,IAAI,KAAK,CAAC,sDAAsD,CAAC,CAAC;YAC1E,CAAC;YACD,IAAI,CAAC;gBAAC,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC;gBACxF,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;YAC3E,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ;oBAAE,MAAM,KAAK,CAAC;YAC/D,CAAC;YACD,MAAM,IAAI,CAAC,cAAc,EAAE,CAAC;YAC5B,IAAI,IAAI,CAAC,MAAM;gBAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACzE,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAC5E,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,CAAC,CAAC;YACnC,IAAI,IAAI,CAAC,MAAM;gBAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACzE,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,SAAS,CAAC;YACrC,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,eAAe,CAAC;YACjD,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;YAClD,IAAI,IAAI,CAAC,MAAM;gBAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACzE,MAAM,KAAK,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,OAAO,EAAE;gBAC3E,YAAY,EAAE,UAAU,EAAE,UAAU,IAAI,CAAC,UAAU,EAAE,EAAE,iBAAiB;gBACxE,IAAI,EAAE,wCAAwC;aAC/C,EAAE,EAAE,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,KAAK,EAAE,KAAK;gBAC9E,QAAQ,EAAE,OAAO,CAAC,QAAQ,KAAK,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,IAAI,EAAE,CAAC,CAAC;YAChF,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;YACnB,IAAI,CAAC,WAAW,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE;gBACvC,KAAK,CAAC,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;gBACrC,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,EAAE,CAAC,CAAC;YACtC,CAAC,CAAC,CAAC;YACH,IAAI,CAAC,KAAK,CAAC,GAAG;gBAAE,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;YAChF,IAAI,QAAQ,GAAwD,IAAI,CAAC;YACzE,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,CAAC;gBAC3D,QAAQ,GAAG,MAAM,uBAAuB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;gBAC1D,IAAI,CAAC,QAAQ;oBAAE,MAAM,IAAI,CAAC,EAAE,CAAC,CAAC;YAChC,CAAC;YACD,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,GAAG,KAAK,KAAK,CAAC,GAAG;gBAAE,MAAM,IAAI,KAAK,CAAC,kEAAkE,CAAC,CAAC;YACjI,MAAM,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,SAAS,CAAC,CAAC;YACpE,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,MAAM,CAAC;YACrC,OAAO,IAAI,EAAE,CAAC;gBACZ,IAAI,IAAI,CAAC,MAAM;oBAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;gBACzE,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC;oBAAE,MAAM,IAAI,KAAK,CAAC,+DAA+D,CAAC,CAAC;gBACtG,IAAI,CAAC;oBACH,IAAI,CAAC,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,QAAQ,EAAE;wBAAE,MAAM;gBAC3E,CAAC;gBAAC,OAAO,KAAK,EAAE,CAAC;oBACf,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,QAAQ;wBAAE,MAAM,KAAK,CAAC;gBAC/D,CAAC;gBACD,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,QAAQ;oBAAE,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;gBAClG,MAAM,IAAI,CAAC,EAAE,CAAC,CAAC;YACjB,CAAC;YACD,MAAM,MAAM,GAAG,IAAI,OAAO,CAAC,YAAY,CAAC,oBAAoB,CAAC;gBAC3D,SAAS,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,IAAI,CAAC,UAAU,EAAE;gBACxD,UAAU,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,UAAU,CAAC,OAAO,EAAE;gBACpF,eAAe,EAAE,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,mBAAmB,EAAE,KAAK;gBAC5E,cAAc,EAAE,YAAY,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC,YAAY,CAAC;gBAC3E,eAAe,EAAE,OAAO,CAAC,EAAE,GAAG,KAAK,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;gBACvE,OAAO,EAAE,GAAG,EAAE;oBACZ,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC;oBAC5B,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;oBACnB,IAAI,QAAQ,IAAI,CAAC,IAAI,CAAC,MAAM;wBAAE,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;gBAC/D,CAAC;aACF,CAAC,CAAC;YACH,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;YACrB,MAAM,MAAM,CAAC,OAAO,EAAE,CAAC;YACvB,IAAI,MAAM,CAAC,aAAa,KAAK,SAAS;gBAAE,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;YACrG,MAAM,KAAK,GAAY,MAAM,MAAM,CAAC,OAAO,CAAC,qBAAqB,EAAE;gBACjE,IAAI,EAAE,mBAAmB,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,gBAAgB,EAAE,OAAO,CAAC,SAAS;aACjG,EAAE,KAAK,CAAC,CAAC;YACV,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,mBAAmB,EAAE,CAAC;gBAC3D,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAC;YAC9E,CAAC;YACD,IAAI,IAAI,CAAC,MAAM;gBAAE,MAAM,IAAI,KAAK,CAAC,sCAAsC,CAAC,CAAC;YACzE,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;QACpB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,CAAC;gBAAC,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;YAAC,CAAC;YAAC,OAAO,YAAY,EAAE,CAAC;gBAChD,MAAM,IAAI,cAAc,CAAC,CAAC,KAAK,EAAE,YAAY,CAAC,EAAE,2CAA2C,CAAC,CAAC;YAC/F,CAAC;YACD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;IAEO,KAAK,CAAC,mBAAmB,CAAC,OAAoD;QACpF,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC3B,IAAI,CAAC,MAAM,IAAI,IAAI,CAAC,MAAM,IAAI,CAAC,IAAI,CAAC,KAAK;YAAE,OAAO;QAClD,IAAI,OAAO,CAAC,MAAM,KAAK,mCAAmC,EAAE,CAAC;YAC3D,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;gBAClC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,kDAAkD,CAAC,CAAC;gBAC7F,OAAO;YACT,CAAC;YACD,IAAI,CAAC;gBACH,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,OAAO,EAAE;oBACpC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,MAAM,CAAC;oBACrD,MAAM,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,IAAI,EAAE,OAAO,CAAC;iBAC3E,CAAC,CAAC;YACL,CAAC;YAAC,MAAM,CAAC;gBACP,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,qCAAqC,CAAC,CAAC;YAClF,CAAC;YACD,OAAO;QACT,CAAC;QACD,MAAM,KAAK,GAAG,IAAI,CAAC,iBAAiB,CAAC;QACrC,MAAM,WAAW,GAAG,IAAI,CAAC,WAAW,CAAC;QACrC,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;QAC9B,IAAI,MAAM,CAAC,MAAM,KAAK,cAAc,IAAI,CAAC,WAAW,IAAI,KAAK,KAAK,SAAS;eACtE,CAAC,MAAM,CAAC,iBAAiB,KAAK,SAAS,IAAI,MAAM,CAAC,iBAAiB,KAAK,IAAI;mBAC1E,MAAM,CAAC,iBAAiB,KAAK,WAAW,CAAC,EAAE,CAAC;YACjD,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,4CAA4C,CAAC,CAAC;YACvF,OAAO;QACT,CAAC;QACD,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAC9E,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC;YAC1C,IAAI,IAAI,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,CAAC,OAAO;gBAAE,OAAO;YAClD,IAAI,SAAS,CAAC,SAAS,KAAK,WAAW,IAAI,SAAS,CAAC,eAAe,IAAI,KAAK,EAAE,CAAC;gBAC9E,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,gDAAgD,CAAC,CAAC;gBAC3F,OAAO;YACT,CAAC;YACD,IAAI,CAAC,iBAAiB,GAAG,SAAS,CAAC,eAAe,CAAC;YACnD,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,EAAE,EAAE,WAAW,EAAE,SAAS,CAAC,WAAW;gBAC7D,gBAAgB,EAAE,SAAS,CAAC,SAAS,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC,CAAC;QACpE,CAAC;QAAC,MAAM,CAAC;YACP,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,OAAO;gBAAE,MAAM,CAAC,aAAa,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,+CAA+C,CAAC,CAAC;QACzH,CAAC;IACH,CAAC;IAED,sGAAsG;IAC/F,kBAAkB;QACvB,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,UAAU;YAAE,MAAM,IAAI,KAAK,CAAC,+BAA+B,CAAC,CAAC;QACxF,OAAO,EAAE,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,OAAO,EAAE,IAAI,EAAE,CAAC,UAAU,EAAE,UAAU,IAAI,CAAC,UAAU,EAAE,CAAC;YACtG,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;IACpE,CAAC;IAED,0GAA0G;IACnG,KAAK,CAAC,WAAW,CAAC,OACD;QACtB,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC;eACrG,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,OAAO,OAAO,CAAC,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC;YACxG,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;QAC7E,CAAC;QACD,MAAM,OAAO,GAAY,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,cAAc,EAAE;YACjE,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,cAAc,EAAE,OAAO,CAAC,cAAc;YAC5E,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACnD,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;YAC7F,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC/D,CAAC;QACD,OAAO,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;IAC3B,CAAC;IAEM,KAAK,CAAC,YAAY,CAAC,QAAgB,EAAE,OACJ;QACtC,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,OAAO,QAAQ,KAAK,QAAQ,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,MAAM,GAAG,GAAG;eAClG,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC;eACrE,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,OAAO,OAAO,CAAC,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC;YACxG,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAC;QAC7E,CAAC;QACD,MAAM,OAAO,GAAY,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,QAAQ;YAC5E,GAAG,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB,EAAE,cAAc,EAAE,OAAO,CAAC,cAAc;YAC5E,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACnD,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3B,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,OAAO,CAAC,MAAM,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;YACtF,MAAM,IAAI,KAAK,CAAC,6EAA6E,CAAC,CAAC;QACjG,CAAC;IACH,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,IAAY,EAAE,OACkB;QACzD,IAAI,CAAC,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,IAAI,OAAO,IAAI,KAAK,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,IAAI,CAAC,MAAM,GAAG,SAAS;eACnG,CAAC,OAAO,IAAI,CAAC,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC,QAAQ,CAAC,OAAO,CAAC,cAAc,CAAC;eACrE,CAAC,OAAO,CAAC,KAAK,KAAK,SAAS,IAAI,CAAC,OAAO,OAAO,CAAC,KAAK,KAAK,QAAQ,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC;eAClG,CAAC,OAAO,CAAC,QAAQ,KAAK,SAAS,IAAI,CAAC,OAAO,OAAO,CAAC,QAAQ,KAAK,QAAQ,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,EAAE,CAAC;YACjH,MAAM,IAAI,KAAK,CAAC,uDAAuD,CAAC,CAAC;QAC3E,CAAC;QACD,IAAI,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC;QAChC,IAAI,QAAQ,EAAE,CAAC;YACb,MAAM,IAAI,CAAC,YAAY,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;QAC7C,CAAC;aAAM,CAAC;YACN,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC7C,CAAC;QACD,MAAM,IAAI,GAAY,MAAM,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,YAAY,EAAE,EAAE,QAAQ;YACtE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC;YAClD,cAAc,EAAE,OAAO,CAAC,cAAc;YACtC,GAAG,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;SACnD,EAAE,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;QAC3B,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,OAAO,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,QAAQ,EAAE,CAAC;YAChF,MAAM,IAAI,KAAK,CAAC,yCAAyC,CAAC,CAAC;QAC7D,CAAC;QACD,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;IAC5C,CAAC;IAEM,KAAK;QACV,IAAI,IAAI,CAAC,YAAY;YAAE,OAAO,IAAI,CAAC,YAAY,CAAC;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC;QAC5B,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC;QACnB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,YAAY,EAAE,CAAC;QACxC,IAAI,QAAQ;YAAE,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;QAC7C,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAEO,KAAK,CAAC,YAAY;QACxB,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC,wBAAwB,CAAC,CAAC;QAC7C,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC;QACzB,IAAI,KAAK,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,GAAG,EAAE,CAAC;YACzC,IAAI,CAAC;gBAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;YAAC,CAAC;YACvF,OAAO,KAAK,EAAE,CAAC;gBAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;oBAAE,MAAM,KAAK,CAAC;YAAC,CAAC;YAC9E,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACpD,IAAI,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;gBACnB,IAAI,CAAC;oBAAC,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,KAAK,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;gBAAC,CAAC;gBACvF,OAAO,KAAK,EAAE,CAAC;oBAAC,IAAI,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,OAAO;wBAAE,MAAM,KAAK,CAAC;gBAAC,CAAC;gBAC9E,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACtD,CAAC;YACD,IAAI,OAAO,CAAC,KAAK,CAAC;gBAAE,MAAM,IAAI,KAAK,CAAC,qCAAqC,CAAC,CAAC;QAC7E,CAAC;QACD,IAAI,IAAI,CAAC,YAAY;YAAE,MAAM,OAAO,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAI,CAAC,YAAY,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC;IAC3G,CAAC;CACF"}

package/dist_ts/index.d.ts

@@ -24,5 +24,6 @@ export * from './classes.watch.js';
 export * from './classes.watchlock.js';
 export * from './watchpolicy.js';
 export * from './classes.authorityclient.js';
+export * from './classes.authoritydaemon.js';
 export * from './classes.authorityservice.js';
 export declare const runCli: (argvArg?: string[]) => Promise<void>;

package/dist_ts/index.js

@@ -24,6 +24,7 @@ export * from './classes.watch.js';
 export * from './classes.watchlock.js';
 export * from './watchpolicy.js';
 export * from './classes.authorityclient.js';
+export * from './classes.authoritydaemon.js';
 export * from './classes.authorityservice.js';
 import { AuthSwitchCli } from './classes.cli.js';
 import { AuthSwitchAuthorityService, resolveAuthSwitchAuthorityPaths, runAuthSwitchAuthorityDaemon } from './classes.authorityservice.js';
@@ -53,4 +54,4 @@ export const runCli = async (argvArg = process.argv.slice(2)) => {
     const exitCode = await new AuthSwitchCli().run(argvArg);
     process.exitCode = exitCode;
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/plugins.d.ts

@@ -28,4 +28,5 @@ import * as flexModels from '@modelprofile.com/flexharness-models';
 import * as flexOpenAi from '@modelprofile.com/flexharness-providers/openai';
 import * as flexAuth from '@modelprofile.com/flexharness-providers/auth';
 import * as flexAccounts from '@modelprofile.com/flexharness-providers/accounts';
-export { flexModels, flexOpenAi, flexAuth, flexAccounts };
+import * as crossharness from '@modelprofile.com/mcp-crossharness';
+export { flexModels, flexOpenAi, flexAuth, flexAccounts, crossharness };

package/dist_ts/plugins.js

@@ -29,5 +29,6 @@ import * as flexModels from '@modelprofile.com/flexharness-models';
 import * as flexOpenAi from '@modelprofile.com/flexharness-providers/openai';
 import * as flexAuth from '@modelprofile.com/flexharness-providers/auth';
 import * as flexAccounts from '@modelprofile.com/flexharness-providers/accounts';
-export { flexModels, flexOpenAi, flexAuth, flexAccounts };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM1QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBR3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLGFBQWEsRUFBRSxFQUFFLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVsRSxNQUFNLGFBQWEsR0FBRyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNyRCxrR0FBa0c7QUFDbEcsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLEdBQWlDLEVBQUUsQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLENBQUM7QUFLM0Y7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsR0FBNkIsRUFBRSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBRTVGLHNCQUFzQjtBQUN0QixPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQUUsV0FBVyxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsQ0FBQztBQUVwRiw0QkFBNEI7QUFDNUIsT0FBTyxLQUFLLFVBQVUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNuRSxPQUFPLEtBQUssVUFBVSxNQUFNLGdEQUFnRCxDQUFDO0FBQzdFLE9BQU8sS0FBSyxRQUFRLE1BQU0sOENBQThDLENBQUM7QUFDekUsT0FBTyxLQUFLLFlBQVksTUFBTSxrREFBa0QsQ0FBQztBQUNqRixPQUFPLEVBQUUsVUFBVSxFQUFFLFVBQVUsRUFBRSxRQUFRLEVBQUUsWUFBWSxFQUFFLENBQUMifQ==
+import * as crossharness from '@modelprofile.com/mcp-crossharness';
+export { flexModels, flexOpenAi, flexAuth, flexAccounts, crossharness };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGx1Z2lucy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3BsdWdpbnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsc0JBQXNCO0FBQ3RCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxFQUFFLE1BQU0sU0FBUyxDQUFDO0FBQzlCLE9BQU8sS0FBSyxJQUFJLE1BQU0sV0FBVyxDQUFDO0FBQ2xDLE9BQU8sS0FBSyxZQUFZLE1BQU0sb0JBQW9CLENBQUM7QUFDbkQsT0FBTyxLQUFLLE1BQU0sTUFBTSxhQUFhLENBQUM7QUFDdEMsT0FBTyxLQUFLLEdBQUcsTUFBTSxVQUFVLENBQUM7QUFDaEMsT0FBTyxFQUFFLGFBQWEsRUFBRSxNQUFNLGFBQWEsQ0FBQztBQUM1QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBR3pDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxFQUFFLGFBQWEsRUFBRSxFQUFFLEVBQUUsR0FBRyxFQUFFLEVBQUUsRUFBRSxJQUFJLEVBQUUsQ0FBQztBQUVsRSxNQUFNLGFBQWEsR0FBRyxhQUFhLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztBQUNyRCxrR0FBa0c7QUFDbEcsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHLEdBQWlDLEVBQUUsQ0FBQyxhQUFhLENBQUMsYUFBYSxDQUFDLENBQUM7QUFLM0Y7OztHQUdHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sa0JBQWtCLEdBQUcsR0FBNkIsRUFBRSxDQUFDLE1BQU0sQ0FBQyxpQkFBaUIsQ0FBQyxDQUFDO0FBRTVGLHNCQUFzQjtBQUN0QixPQUFPLEtBQUssWUFBWSxNQUFNLDBCQUEwQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxTQUFTLE1BQU0sdUJBQXVCLENBQUM7QUFDbkQsT0FBTyxLQUFLLE9BQU8sTUFBTSxxQkFBcUIsQ0FBQztBQUMvQyxPQUFPLEtBQUssV0FBVyxNQUFNLHlCQUF5QixDQUFDO0FBQ3ZELE9BQU8sS0FBSyxXQUFXLE1BQU0seUJBQXlCLENBQUM7QUFDdkQsT0FBTyxLQUFLLFlBQVksTUFBTSwwQkFBMEIsQ0FBQztBQUN6RCxPQUFPLEVBQUUsWUFBWSxFQUFFLFNBQVMsRUFBRSxPQUFPLEVBQUUsV0FBVyxFQUFFLFdBQVcsRUFBRSxZQUFZLEVBQUUsQ0FBQztBQUVwRiw0QkFBNEI7QUFDNUIsT0FBTyxLQUFLLFVBQVUsTUFBTSxzQ0FBc0MsQ0FBQztBQUNuRSxPQUFPLEtBQUssVUFBVSxNQUFNLGdEQUFnRCxDQUFDO0FBQzdFLE9BQU8sS0FBSyxRQUFRLE1BQU0sOENBQThDLENBQUM7QUFDekUsT0FBTyxLQUFLLFlBQVksTUFBTSxrREFBa0QsQ0FBQztBQUNqRixPQUFPLEtBQUssWUFBWSxNQUFNLG9DQUFvQyxDQUFDO0FBQ25FLE9BQU8sRUFBRSxVQUFVLEVBQUUsVUFBVSxFQUFFLFFBQVEsRUFBRSxZQUFZLEVBQUUsWUFBWSxFQUFFLENBQUMifQ==

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelprofile.com/authswitch",
-  "version": "6.4.0",
+  "version": "6.5.0",
   "private": false,
   "description": "Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status",
   "main": "dist_ts/index.js",
@@ -21,6 +21,10 @@
     "./authority-client": {
       "types": "./dist_ts/classes.authorityclient.d.ts",
       "import": "./dist_ts/classes.authorityclient.js"
+    },
+    "./authority-daemon": {
+      "types": "./dist_ts/classes.authoritydaemon.d.ts",
+      "import": "./dist_ts/classes.authoritydaemon.js"
     }
   },
   "type": "module",
@@ -45,13 +49,16 @@
     "@git.zone/tsrun": "^2.0.6",
     "@git.zone/tstest": "^6.1.1",
     "@types/node": "26.5.1",
-    "esbuild": "^0.28.2"
+    "@types/ws": "8.18.1",
+    "esbuild": "^0.28.2",
+    "ws": "8.21.2"
   },
   "dependencies": {
     "@api.global/typedrequest": "8.1.0",
     "@api.global/typedrequest-interfaces": "7.1.0",
     "@modelprofile.com/flexharness-models": "^8.0.0",
     "@modelprofile.com/flexharness-providers": "^8.0.0",
+    "@modelprofile.com/mcp-crossharness": "5.4.0",
     "@push.rocks/smartconsole": "^1.3.0",
     "@push.rocks/smartdaemon": "2.7.0",
     "@push.rocks/smartdata": "11.14.2",

package/readme.md

@@ -46,8 +46,33 @@ Browser code can import the credential-free DTOs from
 `@modelprofile.com/authswitch/authority-contract`. A backend binds an account to a
 runtime incarnation and keeps the returned capability private. The runtime-only socket
 resolves that binding to a current access token; its directory can be mounted into a
-container without exposing the management socket. Reconnect and reload a snapshot after
-an event gap or daemon restart.
+container without exposing the management socket. A provider that rejects a specific
+access-token generation can request a newer one through `rejectedGrantGeneration`; the
+authority coalesces concurrent rejection callbacks and never replays an uncertain refresh.
+
+`AuthSwitchClient.subscribe(onSnapshot, onEvent, signal, { onStatus })` reports `current`
+after a fresh snapshot or verified heartbeat, `unavailable` on disconnect or resync, and
+`closed` on abort. Keep cached account actions disabled while status is not `current`.
+Every change-event batch supplies a fresh snapshot before `onEvent`, so a consumer does
+not need to reconstruct account state from events. `lastVerifiedAt` records the last
+successful daemon response, including an empty heartbeat.
+
+A trusted in-process daemon host can call `AuthSwitchAuthorityDaemon.startManagedCodex()`
+for a bound account and workspace. It owns a private Codex 0.155.1 app-server, passes only
+the authority's current access token through Codex's external-token login, answers its
+unauthorized callback through the authority, and revokes the binding on stop. The returned
+runtime exposes an interactive `codex --remote unix://…` launch descriptor and native
+`thread/start`, `thread/resume` and `turn/start` methods for noninteractive consumers.
+Callers supply a private, durable `codexHomeDirectory` for Codex's own configuration and
+conversation state. SmartData binds that home immutably to one account and scope, and the
+daemon records its active process/socket identity before launching it. Admission refuses
+an existing nonempty native home or a surviving app-server owner; a fresh empty home is
+created on first use. Account removal drains its managed Codex processes before the
+grant is removed, and targeted reauthentication holds new admissions until the device
+operation settles. Only the private socket directory is removed on close. Codex's
+credential store remains ephemeral and does not read or write `auth.json` in that home.
+Codex 0.155.1 does not persist an unused thread created by `thread/start`; resume applies
+after Codex has committed a rollout. The existing CLI has not yet been moved to this path.
 
 This SDK is additive at this stage. The commands documented below still use the existing
 credential stores. The authority daemon does not import those stores automatically,

package/ts/00_commitinfo_data.ts

@@ -3,6 +3,6 @@
  */
 export const commitinfo = {
   name: '@modelprofile.com/authswitch',
-  version: '6.4.0',
+  version: '6.5.0',
   description: 'Manage Codex, OpenCode and Claude Code accounts with guided switching and live usage status'
 }

package/ts/authority-runtime-contract.ts

@@ -16,7 +16,13 @@ export interface IReq_AuthSwitchBindAccount extends ITypedRequest {
 /** Backend-only access operation. Refresh grants never cross this interface. */
 export interface IReq_AuthSwitchResolveAccess extends ITypedRequest {
   method: 'authswitch.authority.resolveAccess';
-  request: { bindingId: string; capability: string; minValidityMs: number };
+  request: {
+    bindingId: string;
+    capability: string;
+    minValidityMs: number;
+    /** The provider rejected this exact access-token generation. */
+    rejectedGrantGeneration?: number;
+  };
   response: {
     accessToken: string;
     accountId: string;

package/ts/classes.authoritybroker.ts

@@ -317,6 +317,13 @@ export class AuthSwitchAuthorityBroker {
     return structuredClone(operation.public);
   }
 
+  /** Trusted daemon lifecycle hook: hold new managed runtimes out until targeted reauth settles. */
+  public async waitOperation(operationId: string): Promise<void> {
+    const operation = this.operations.get(operationId);
+    if (!isUuid(operationId) || !operation) throw new Error('Account operation expired or was not found.');
+    await operation.task;
+  }
+
   private pruneOperations(): void {
     for (const [id, operation] of this.operations) {
       if (operation.finishedAt !== null && this.now() - operation.finishedAt > 600_000) this.operations.delete(id);
@@ -379,9 +386,19 @@ export class AuthSwitchAuthorityBroker {
     return { binding: publicBinding(updated.binding), capability };
   }
 
-  public async resolveAccess(bindingId: string, capability: string, minValidityMs: number): Promise<IAuthSwitchResolvedAccess> {
+  public async revokeBinding(bindingId: string, capability: string): Promise<boolean> {
+    if (!isId(bindingId) || !/^[A-Za-z0-9_-]{43}$/.test(capability)) throw new Error('Invalid runtime binding revocation.');
+    const revoked = await this.database.revokeBinding(plugins.crypto.randomUUID(), bindingId, idHash(capability));
+    if (revoked) this.publish();
+    return revoked;
+  }
+
+  public async resolveAccess(bindingId: string, capability: string, minValidityMs: number,
+    rejectedGrantGeneration?: number): Promise<IAuthSwitchResolvedAccess> {
     if (!isId(bindingId) || !/^[A-Za-z0-9_-]{43}$/.test(capability)
-      || !Number.isSafeInteger(minValidityMs) || minValidityMs < 0 || minValidityMs > 3_600_000) throw new Error('Invalid runtime credential request.');
+      || !Number.isSafeInteger(minValidityMs) || minValidityMs < 0 || minValidityMs > 3_600_000
+      || (rejectedGrantGeneration !== undefined && (!Number.isSafeInteger(rejectedGrantGeneration)
+        || rejectedGrantGeneration < 1))) throw new Error('Invalid runtime credential request.');
     const supplied = Buffer.from(idHash(capability), 'hex');
     for (let attempt = 0; attempt < 4; attempt++) {
       const initial = await this.database.readBindingContext(bindingId);
@@ -395,6 +412,9 @@ export class AuthSwitchAuthorityBroker {
         || binding.grantAuthorizationGeneration !== grant.authorizationGeneration) {
         throw new Error('Account needs reauthentication.');
       }
+      if (rejectedGrantGeneration !== undefined && rejectedGrantGeneration > grant.grantGeneration) {
+        throw new Error('Provider rejected a future account grant generation.');
+      }
       if (grant.state === 'exchange_may_have_been_sent') {
         const inFlight = this.refreshes.get(account.id);
         if (!inFlight) throw new Error('Account refresh is unresolved; reauthentication is required.');
@@ -405,9 +425,10 @@ export class AuthSwitchAuthorityBroker {
         || !['ready', 'retry_wait'].includes(grant.state)) {
         throw new Error('Account needs reauthentication.');
       }
-      if (this.isDue(grant, minValidityMs)) {
+      const rejectedCurrent = rejectedGrantGeneration === grant.grantGeneration;
+      if (this.isDue(grant, minValidityMs) || rejectedCurrent) {
         if (grant.state === 'ready' || (grant.retryAt !== null && Date.parse(grant.retryAt) <= this.now())) {
-          await this.refreshAccount(account.id);
+          await this.refreshAccount(account.id, rejectedCurrent ? rejectedGrantGeneration : undefined);
           continue;
         }
         throw new Error('Account access credential is not fresh enough.');
@@ -431,7 +452,8 @@ export class AuthSwitchAuthorityBroker {
       }
       if (latest.grant.grantGeneration !== grant.grantGeneration
         || latest.grant.state === 'exchange_may_have_been_sent') continue;
-      if (!['ready', 'retry_wait'].includes(latest.grant.state) || this.isDue(latest.grant, minValidityMs)) {
+      if (!['ready', 'retry_wait'].includes(latest.grant.state) || this.isDue(latest.grant, minValidityMs)
+        || (rejectedGrantGeneration !== undefined && latest.grant.grantGeneration === rejectedGrantGeneration)) {
         throw new Error('Account access credential is not fresh enough.');
       }
       return { accessToken: credential.accessToken, accountId: account.workspaceId,
@@ -441,20 +463,20 @@ export class AuthSwitchAuthorityBroker {
     throw new Error('Account credential rotated repeatedly during resolution; retry the request.');
   }
 
-  private async refreshAccount(accountId: string): Promise<void> {
+  private async refreshAccount(accountId: string, rejectedGrantGeneration?: number): Promise<void> {
     const prior = this.refreshes.get(accountId);
     if (prior) return prior;
-    const task = this.performRefresh(accountId).finally(() => { if (this.refreshes.get(accountId) === task) this.refreshes.delete(accountId); });
+    const task = this.performRefresh(accountId, rejectedGrantGeneration).finally(() => { if (this.refreshes.get(accountId) === task) this.refreshes.delete(accountId); });
     this.refreshes.set(accountId, task);
     return task;
   }
 
-  private async performRefresh(accountId: string): Promise<void> {
+  private async performRefresh(accountId: string, rejectedGrantGeneration?: number): Promise<void> {
     const initial = await this.database.readAccountAndPrimaryGrant(accountId);
     const initialGrant = initial.grant;
     if (!initial.account || initial.account.removed || !initialGrant || initialGrant.purpose !== 'openai_managed'
       || !['ready', 'retry_wait'].includes(initialGrant.state) || initialGrant.owner !== 'daemon'
-      || !this.isDue(initialGrant, 0)
+      || (!this.isDue(initialGrant, 0) && initialGrant.grantGeneration !== rejectedGrantGeneration)
       || (initialGrant.state === 'retry_wait'
         && (initialGrant.retryAt === null || Date.parse(initialGrant.retryAt) > this.now()))) return;
     const credential = await this.unsealCredential(initial.account, initialGrant);