@ours.network/fleet 1.2.0-nightly.21 → 1.2.0-nightly.23

package/dist/application/conversation-history.d.ts

@@ -1,4 +1,23 @@
+import type { ConversationEventV1 } from '../session/conversation-types.js';
 import type { ConversationPageView } from './session-control.js';
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export declare function conversationEventVisible(event: ConversationEventV1, sessionGeneration: string, resumedSessionId?: string): boolean;
+export interface ConversationTailPage extends ConversationPageView {
+    /** Pass as `before` to read the next older page. */
+    olderCursor?: string;
+    hasOlder: boolean;
+    /** Latest page only: older events the view still needs, the current session's latest capabilities and still-pending permission requests. */
+    context: ConversationEventV1[];
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export declare function conversationTailPage(stateDir: string, request: {
+    before?: string;
+    limit?: number;
+}, snapshot: ConversationPageView['snapshot'], resumedSessionId?: string): Promise<ConversationTailPage>;
 /** Read the existing ACP session ledger without opening its writer/recovery store. */
 export declare function resumedConversationPage(stateDir: string, request: {
     after?: string;

package/dist/application/conversation-history.js

@@ -1,7 +1,127 @@
 import { createReadStream } from 'node:fs';
-import { readFile, readdir } from 'node:fs/promises';
+import { open, readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
+const HISTORICAL_KINDS = ['fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'];
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export function conversationEventVisible(event, sessionGeneration, resumedSessionId) {
+    return event.source !== 'agent_replay' && (event.sessionGeneration === sessionGeneration || (!!resumedSessionId && HISTORICAL_KINDS.includes(event.kind) && event.acpSessionId === resumedSessionId));
+}
+/** Newest-first lines of a file, read in chunks from its end; `visit` returns false to stop. */
+async function readLinesBackward(path, visit) {
+    const file = await open(path, 'r');
+    try {
+        let position = (await file.stat()).size;
+        let carry = Buffer.alloc(0);
+        while (position > 0) {
+            const size = Math.min(256 * 1024, position);
+            position -= size;
+            const chunk = Buffer.alloc(size);
+            await file.read(chunk, 0, size, position);
+            let buffer = Buffer.concat([chunk, carry]);
+            let end = buffer.length;
+            for (let i = buffer.length - 1; i >= 0; i--) {
+                if (buffer[i] !== 10)
+                    continue;
+                if (end > i + 1 && !visit(buffer.toString('utf8', i + 1, end)))
+                    return false;
+                end = i;
+            }
+            carry = buffer.subarray(0, end);
+        }
+        if (carry.length && !visit(carry.toString('utf8')))
+            return false;
+        return true;
+    }
+    finally {
+        await file.close();
+    }
+}
+/** The last event cursor in a segment, read from its tail; undefined when none is readable. */
+async function lastSeq(path) {
+    let seq;
+    await readLinesBackward(path, line => { try {
+        const value = Number(JSON.parse(line).seq);
+        if (Number.isSafeInteger(value)) {
+            seq = value;
+            return false;
+        }
+    }
+    catch { } return true; });
+    return seq;
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export async function conversationTailPage(stateDir, request, snapshot, resumedSessionId) {
+    const before = request.before === undefined ? Infinity : Number(request.before);
+    if (before !== Infinity && (!Number.isSafeInteger(before) || before < 0))
+        throw new Error('before must be a ledger cursor');
+    const limit = Math.min(1000, Math.max(1, Number.isFinite(request.limit) ? Math.floor(request.limit) : 200));
+    let files = [];
+    try {
+        files = (await readdir(join(stateDir, '.conversation'))).filter(n => /^events-\d{6}\.jsonl$/.test(n)).sort().reverse();
+    }
+    catch { }
+    const events = [];
+    let newest;
+    let hasOlder = false;
+    const pending = new Set(snapshot.pendingPermissionIds);
+    let capabilities;
+    const context = [];
+    // Context only accompanies the newest page; older pages stop as soon as they are full.
+    const wantsContext = () => before === Infinity && (!capabilities || pending.size > 0);
+    const generation = `"sessionGeneration":${JSON.stringify(snapshot.sessionGeneration)}`;
+    for (const file of files) {
+        const more = await readLinesBackward(join(stateDir, '.conversation', file), line => {
+            if (hasOlder) {
+                // The page is full; only the current generation's context kinds matter. Generations are
+                // appended in order, so the first line of an older one ends the search.
+                if (!line.includes(generation))
+                    return !line.includes('"sessionGeneration":') && wantsContext();
+                if (!line.includes('"capabilities.updated"') && !line.includes('"permission.requested"'))
+                    return wantsContext();
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                return true;
+            }
+            const seq = Number(event.seq);
+            if (!Number.isSafeInteger(seq))
+                return true;
+            newest ??= seq;
+            if (seq < before && conversationEventVisible(event, snapshot.sessionGeneration, resumedSessionId)) {
+                const inPage = !hasOlder && events.length < limit;
+                if (event.sessionGeneration === snapshot.sessionGeneration) {
+                    if (event.kind === 'capabilities.updated' && !capabilities) {
+                        capabilities = event;
+                        if (!inPage)
+                            context.push(event);
+                    }
+                    if (event.kind === 'permission.requested' && event.permissionId && pending.delete(event.permissionId) && !inPage)
+                        context.push(event);
+                }
+                if (inPage)
+                    events.push(event);
+                else
+                    hasOlder = true;
+            }
+            return !hasOlder || wantsContext();
+        });
+        if (!more)
+            break;
+    }
+    events.reverse();
+    context.reverse();
+    return { events, snapshot, hasOlder, context, hasMore: false,
+        ...(events.length ? { olderCursor: String(events[0].seq) } : {}),
+        ...(before === Infinity && newest !== undefined ? { nextCursor: String(newest) } : {}) };
+}
 /** Read the existing ACP session ledger without opening its writer/recovery store. */
 export async function resumedConversationPage(stateDir, request, live, expectedSessionId) {
     let sessionId;
@@ -24,6 +144,10 @@ export async function resumedConversationPage(stateDir, request, live, expectedS
     let first;
     let hasMore = false;
     scan: for (const file of files) {
+        // Forward polling asks for the newest few events: skip whole segments that end at or before the cursor.
+        const end = await lastSeq(join(stateDir, '.conversation', file));
+        if (end !== undefined && end <= after)
+            continue;
         const input = createReadStream(join(stateDir, '.conversation', file), { encoding: 'utf8' });
         const lines = createInterface({ input, crlfDelay: Infinity });
         try {

package/dist/application/session-control.d.ts

@@ -1,3 +1,4 @@
+import { type ConversationTailPage } from './conversation-history.js';
 import type { AgentHistoryQuery } from '../agent-ours/correspondence.js';
 import { controlRequest } from '../session/control.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt } from '../session/conversation-types.js';
@@ -44,6 +45,11 @@ export interface RoleSessionControl {
         after?: string;
         limit?: number;
     }): Promise<ConversationPageView>;
+    /** The newest visible events (or those before `before`), read backwards from the ledger. */
+    conversationTail?(request: {
+        before?: string;
+        limit?: number;
+    }): Promise<ConversationTailPage>;
     submitPromptV2?(request: {
         commandId: string;
         text: string;
@@ -94,6 +100,10 @@ export declare class RoleSessionControlAdapter implements RoleSessionControl {
         after?: string;
         limit?: number;
     }): Promise<ConversationPageView>;
+    conversationTail(request?: {
+        before?: string;
+        limit?: number;
+    }): Promise<ConversationTailPage>;
     submitPromptV2(request: {
         commandId: string;
         text: string;

package/dist/application/session-control.js

@@ -1,4 +1,6 @@
-import { resumedConversationPage } from './conversation-history.js';
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { conversationTailPage, resumedConversationPage } from './conversation-history.js';
 import { controlRequest, followConversation } from '../session/control.js';
 import { FleetError, normalizeError } from './errors.js';
 const visibleEvents = (events) => events.filter(event => event.kind !== 'thought');
@@ -78,13 +80,44 @@ export class RoleSessionControlAdapter {
             return live;
         }
     }
+    async conversationTail(request = {}) {
+        const live = await this.call('conversation_page', { limit: 1 });
+        const snapshot = await this.snapshot();
+        let resumed;
+        if (snapshot.backend === 'acp' && snapshot.sessionId) {
+            try {
+                if ((await readFile(join(this.stateDir, '.acp-session-id'), 'utf8')).trim() === snapshot.sessionId)
+                    resumed = snapshot.sessionId;
+            }
+            catch { /* no resumed history: live generation only */ }
+        }
+        try {
+            return await conversationTailPage(this.stateDir, request, live.snapshot, resumed);
+        }
+        catch (error) {
+            throw new FleetError('invalid_request', error.message);
+        }
+    }
     async submitPromptV2(request) {
         if (!request.text.trim())
             throw new FleetError('invalid_request', 'text is required');
         if (Buffer.byteLength(request.text) > 32 * 1024)
             throw new FleetError('invalid_request', 'text exceeds 32 KiB');
+        // A prompt bound to a session generation (voice or attachments) is checked atomically by supervisors that
+        // support it. Older supervisors do not know that command and never answer, so check the generation here
+        // and submit an ordinary prompt; its command id keeps retries idempotent either way.
+        let command = 'submit_prompt_v2';
+        if (request.expectedSessionGeneration) {
+            if ((await this.describe()).features.includes('generation_bound_prompts'))
+                command = 'submit_voice_prompt';
+            else {
+                const live = await this.call('conversation_page', { limit: 1 });
+                if (live.snapshot?.sessionGeneration !== request.expectedSessionGeneration)
+                    throw new FleetError('stale_state', 'Agent session changed. Record a new voice message.');
+            }
+        }
         try {
-            return await this.call(request.expectedSessionGeneration ? 'submit_voice_prompt' : 'submit_prompt_v2', {
+            return await this.call(command, {
                 commandId: request.commandId, text: request.text, actor: request.actorBrowserSession,
                 source: request.source, expectedSessionGeneration: request.expectedSessionGeneration,
             });

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.21",
-  "buildId": "81e5e1c4c6c2",
-  "commit": "b0e94cd81e42e583d94700929849c53c4dcbe4c1",
+  "version": "1.2.0-nightly.23",
+  "buildId": "84a9c6c0a54c",
+  "commit": "75b0bebdb33a4ace4713015f7a7f49adc330f6e4",
   "dirty": true,
-  "builtAt": "2026-09-29T20:23:31.748Z",
+  "builtAt": "2026-09-30T10:20:51.847Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/isolation/policy.js

@@ -168,6 +168,8 @@ export function resolveIsolation(cfg, ctx) {
     }
     for (const dir of ctx.additionalWriteDirs ?? [])
         addRw(dir);
+    if (ctx.subscriptionHome)
+        addRw(ctx.subscriptionHome);
     // The selected harness/session command may live outside the system allowlist
     // (for example Node and a bundled ACP adapter under ~/.local). The runner
     // resolves its exact executable/package closure; keep every such bind RO.

package/dist/isolation/types.d.ts

@@ -63,6 +63,11 @@ export interface WrapContext {
      * them for itself or for its peers.
      */
     harnessSharedPaths?: string[];
+    /**
+     * The pinned subscription profile home (CLAUDE_CONFIG_DIR / CODEX_HOME), mounted
+     * read-write so the CLI can refresh that profile's login. Absent for the default.
+     */
+    subscriptionHome?: string;
     /** Exact launcher/interpreter/module closure required by the selected command. */
     runtimeReadPaths?: string[];
     brokerEndpoint?: string;

package/dist/runner.js

@@ -14,6 +14,7 @@ import { createMonitor, probeIdentityPresence, } from './monitor.js';
 import { DaemonGenerationObserver, RoleRecoveryController, probeDaemonGeneration, } from './daemon-recovery.js';
 import { realExec } from './exec.js';
 import { resolveIsolation } from './isolation/policy.js';
+import { pinSubscriptionForLaunch } from './subscriptions/launch.js';
 import { selectIsolationBackend } from './isolation/registry.js';
 import { resourceArgs, cpuControllerDelegated } from './isolation/resources.js';
 import { resolveLaunchRuntime } from './isolation/runtime.js';
@@ -525,6 +526,11 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     const sessionBackend = role.session ?? 'acp';
     const sessionLabel = sessionBackend === 'acp' ? 'ACP' : 'Codex app-server';
     let launch = adapter.agentSession.prepareLaunch(role, prep);
+    // Resolve the fleet-wide active subscription profile once, now: a later switch
+    // never changes this session (the operator restarts agents to move them).
+    const subscription = pinSubscriptionForLaunch(role, dir);
+    if (subscription?.pin.home)
+        deps.log(`[${name}] subscription: ${subscription.pin.provider} profile ${subscription.pin.profileId}`);
     // Preserve the role's existing isolation policy.
     let wrappedArgv = launch.argv;
     if (role.isolation) {
@@ -535,6 +541,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         launch = { ...launch, argv: runtime.argv };
         const ctx = {
             ...isolationContextFor(role), stateDir: dir, runCwd,
+            subscriptionHome: subscription?.writablePath,
             runtimeReadPaths: [...runtime.readPaths, ...resolveLaunchRuntime([process.execPath, fileURLToPath(new URL('./agent-ours/bridge.js', import.meta.url))]).readPaths],
         };
         const policy = resolveIsolation(role.isolation, ctx);
@@ -560,7 +567,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     const managedService = await deps.prepareAgentOurs(role, dir, opts.identityLifetime ? opts.identityLifetime === 'temporary' : temp);
     let layoutRetiring = false;
     try {
-        const managedHarness = prepareManagedHarness(role, dir, runCwd, managedService.descriptor, harnessChildEnv(role, launch.env, dir));
+        const managedHarness = prepareManagedHarness(role, dir, runCwd, managedService.descriptor, { ...harnessChildEnv(role, launch.env, dir), ...subscription?.env });
         // Start-stagger: space this launch at least start_stagger_ms after the previous
         // agent launch across the whole host, so a burst of boots (systemd starts every
         // user unit concurrently on boot; `ours-fleet up`/restart-all bulk-start) does not

package/dist/session/acp.js

@@ -8,6 +8,7 @@ import * as acp from '@agentclientprotocol/sdk';
 import { normalizeSessionUpdate } from './conversation-normalizer.js';
 import { ConversationEventStore } from './conversation-store.js';
 import { SessionEvents } from './events.js';
+import { recordClaudeRateLimit } from '../subscriptions/observed.js';
 import { DEFAULT_STALL_TIMEOUT_MS, STALL_RECOVERY_PROMPT, StallWatchdog, StallToolHistory, hasStallRecoveryClaim } from './stall-watchdog.js';
 import { ACP_CANCEL_DEADLINE_EXCEEDED, SessionControlError, classifyChildExit, sessionBackendCapabilities, turnResult, } from './types.js';
 const CANCEL_SETTLE_GRACE_MS = 15_000;
@@ -1713,6 +1714,12 @@ export class AcpSession {
         this.recordConversationUpdate(update, scheduled, messagePhase === 'commentary');
         if (update.sessionUpdate === 'config_option_update')
             this.captureRuntimeMetadata(update.configOptions);
+        if (update.sessionUpdate === 'usage_update') {
+            // Claude subscription rate-limit snapshot (claude-agent-acp forwards the SDK rate_limit_event).
+            const rateLimit = update._meta?.['_claude/rateLimit'];
+            if (rateLimit)
+                recordClaudeRateLimit(this.options.stateDir, rateLimit);
+        }
         switch (update.sessionUpdate) {
             case 'agent_message_chunk': {
                 const phase = messagePhase;

package/dist/session/control.js

@@ -242,6 +242,7 @@ export class RoleControlServer {
                                 'events_since', 'observer_follow', 'retained_range',
                                 ...(this.correspondence ? ['agent_correspondence'] : []),
                                 ...(this.session.conversationPage ? ['conversation_v3'] : []),
+                                ...(this.session.submitPromptBrowser ? ['generation_bound_prompts'] : []),
                                 ...(this.session.capabilities?.steering ? ['steering'] : []),
                                 ...(this.session.capabilities?.permissions ? ['permissions'] : []),
                                 ...(this.session.capabilities?.messagePhases ? ['message_phases'] : []),

package/dist/subscriptions/cli.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Thin adapters over the official CLIs. Nothing here reads or returns a token
+ * value: credentials stay in files the CLIs own, and secrets typed by the user
+ * (a Claude paste code) travel only over a child's stdin, never argv or logs.
+ */
+export interface SubscriptionBinaries {
+    claude: string;
+    codex: string;
+    /** `script(1)`, used to give `claude auth login` the terminal it expects. */
+    script: string;
+}
+export declare const defaultBinaries: () => SubscriptionBinaries;
+/**
+ * Child env for a profile helper: explicit home for added profiles, the CLI
+ * default otherwise. Every credential selector either CLI honours is removed,
+ * so a helper can only ever see the profile's own login.
+ */
+export declare function profileEnv(homeVar: string, profileId: string, home: string, base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
+export interface ClaudeStatus {
+    loggedIn: boolean;
+    email?: string;
+    plan?: string;
+    org?: string;
+    authMethod?: string;
+}
+/** `claude auth status --json` (documented: exit 0 when logged in, 1 otherwise). */
+export declare function claudeAuthStatus(bin: string, env: NodeJS.ProcessEnv, timeoutMs?: number): Promise<ClaudeStatus>;
+/**
+ * Login expiry timestamps from the Claude credentials file. Field names are
+ * observed (Claude Code 2.1.x), not a documented contract, so absence is normal.
+ * Only the two numbers are kept; the parsed object is discarded immediately.
+ */
+export declare function claudeLoginExpiry(home: string): {
+    accessExpiresAt?: number;
+    refreshExpiresAt?: number;
+};
+/** Minimal stdio JSON-RPC client for `codex app-server` (the supported transport). */
+export declare class CodexAppServer {
+    private readonly child;
+    private id;
+    private buffer;
+    private readonly pending;
+    private readonly listeners;
+    private closed;
+    private constructor();
+    static start(bin: string, env: NodeJS.ProcessEnv): Promise<CodexAppServer>;
+    call<T = unknown>(method: string, params: unknown, timeoutMs?: number): Promise<T>;
+    onNotification(fn: (method: string, params: unknown) => void): () => void;
+    close(): void;
+    private onData;
+}
+/** One-shot use of an app-server for a profile. */
+export declare function withCodex<T>(bin: string, env: NodeJS.ProcessEnv, fn: (s: CodexAppServer) => Promise<T>): Promise<T>;
+export interface UsageWindow {
+    id: string;
+    label: string;
+    usedPercent: number;
+    windowMins?: number;
+    resetsAt?: string;
+}
+interface CodexWindow {
+    usedPercent?: number;
+    windowDurationMins?: number | null;
+    resetsAt?: number | null;
+}
+interface CodexSnapshot {
+    limitId?: string | null;
+    limitName?: string | null;
+    primary?: CodexWindow | null;
+    secondary?: CodexWindow | null;
+}
+/** Flatten `account/rateLimits/read` into display windows. */
+export declare function codexUsageWindows(result: {
+    rateLimits?: CodexSnapshot;
+    rateLimitsByLimitId?: Record<string, CodexSnapshot | undefined> | null;
+}): UsageWindow[];
+export declare function windowName(mins?: number): string;
+export {};

package/dist/subscriptions/cli.js

@@ -0,0 +1,186 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { CONFLICTING_AUTH_ENV } from './launch.js';
+import { DEFAULT_PROFILE_ID } from './store.js';
+export const defaultBinaries = () => ({
+    claude: process.env.OURS_FLEET_CLAUDE_BIN ?? 'claude',
+    codex: process.env.OURS_FLEET_CODEX_BIN ?? 'codex',
+    script: 'script',
+});
+/**
+ * Child env for a profile helper: explicit home for added profiles, the CLI
+ * default otherwise. Every credential selector either CLI honours is removed,
+ * so a helper can only ever see the profile's own login.
+ */
+export function profileEnv(homeVar, profileId, home, base = process.env) {
+    const env = { ...base, BROWSER: 'true', NO_COLOR: '1' };
+    for (const key of [...CONFLICTING_AUTH_ENV.claude, ...CONFLICTING_AUTH_ENV.codex, 'ANTHROPIC_BASE_URL', 'OPENAI_BASE_URL'])
+        delete env[key];
+    if (profileId !== DEFAULT_PROFILE_ID)
+        env[homeVar] = home;
+    return env;
+}
+/** `claude auth status --json` (documented: exit 0 when logged in, 1 otherwise). */
+export function claudeAuthStatus(bin, env, timeoutMs = 20_000) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(bin, ['auth', 'status', '--json'], { env, stdio: ['ignore', 'pipe', 'ignore'] });
+        let out = '';
+        const timer = setTimeout(() => { child.kill('SIGKILL'); reject(new Error('claude auth status timed out')); }, timeoutMs);
+        child.stdout.on('data', d => { out += d; if (out.length > 64 * 1024)
+            child.kill('SIGKILL'); });
+        child.once('error', error => { clearTimeout(timer); reject(error); });
+        child.once('close', code => {
+            clearTimeout(timer);
+            let parsed = {};
+            try {
+                parsed = JSON.parse(out);
+            }
+            catch { /* non-JSON: rely on exit code */ }
+            const str = (v) => typeof v === 'string' && v ? v.slice(0, 120) : undefined;
+            resolve({
+                loggedIn: code === 0 && parsed.loggedIn !== false,
+                email: str(parsed.email), plan: str(parsed.subscriptionType), org: str(parsed.orgName),
+                authMethod: str(parsed.authMethod),
+            });
+        });
+    });
+}
+/**
+ * Login expiry timestamps from the Claude credentials file. Field names are
+ * observed (Claude Code 2.1.x), not a documented contract, so absence is normal.
+ * Only the two numbers are kept; the parsed object is discarded immediately.
+ */
+export function claudeLoginExpiry(home) {
+    try {
+        const oauth = JSON.parse(readFileSync(join(home, '.credentials.json'), 'utf8')).claudeAiOauth;
+        const num = (v) => typeof v === 'number' && Number.isFinite(v) ? v : undefined;
+        return { accessExpiresAt: num(oauth?.expiresAt), refreshExpiresAt: num(oauth?.refreshTokenExpiresAt) };
+    }
+    catch {
+        return {};
+    }
+}
+/** Minimal stdio JSON-RPC client for `codex app-server` (the supported transport). */
+export class CodexAppServer {
+    child;
+    id = 0;
+    buffer = '';
+    pending = new Map();
+    listeners = new Set();
+    closed = false;
+    constructor(child) {
+        this.child = child;
+        child.stdout.on('data', chunk => this.onData(String(chunk)));
+        child.stdin.on('error', () => { });
+        child.stderr.resume();
+        child.once('close', () => {
+            this.closed = true;
+            for (const p of this.pending.values())
+                p.reject(new Error('codex app-server exited'));
+            this.pending.clear();
+        });
+    }
+    static async start(bin, env) {
+        const child = spawn(bin, ['app-server'], { env, stdio: ['pipe', 'pipe', 'pipe'] });
+        await new Promise((resolve, reject) => { child.once('spawn', resolve); child.once('error', reject); });
+        const server = new CodexAppServer(child);
+        await server.call('initialize', { clientInfo: { name: 'ours-fleet', title: 'Ours Fleet', version: '1' } });
+        child.stdin.write(`${JSON.stringify({ method: 'initialized' })}\n`);
+        return server;
+    }
+    call(method, params, timeoutMs = 20_000) {
+        if (this.closed)
+            return Promise.reject(new Error('codex app-server exited'));
+        const id = ++this.id;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`${method} timed out`)); }, timeoutMs);
+            this.pending.set(id, {
+                resolve: v => { clearTimeout(timer); resolve(v); },
+                reject: e => { clearTimeout(timer); reject(e); },
+            });
+            this.child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+        });
+    }
+    onNotification(fn) {
+        this.listeners.add(fn);
+        return () => this.listeners.delete(fn);
+    }
+    close() {
+        if (!this.closed)
+            this.child.kill();
+    }
+    onData(chunk) {
+        this.buffer += chunk;
+        for (let i = this.buffer.indexOf('\n'); i >= 0; i = this.buffer.indexOf('\n')) {
+            const line = this.buffer.slice(0, i).trim();
+            this.buffer = this.buffer.slice(i + 1);
+            if (!line)
+                continue;
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (typeof message.id === 'number' && this.pending.has(message.id) && !message.method) {
+                const p = this.pending.get(message.id);
+                this.pending.delete(message.id);
+                if (message.error)
+                    p.reject(Object.assign(new Error(String(message.error.message ?? 'codex error').slice(0, 300)), { rpcCode: message.error.code }));
+                else
+                    p.resolve(message.result);
+            }
+            else if (message.method) {
+                for (const fn of this.listeners)
+                    fn(message.method, message.params);
+            }
+        }
+    }
+}
+/** One-shot use of an app-server for a profile. */
+export async function withCodex(bin, env, fn) {
+    const server = await CodexAppServer.start(bin, env);
+    try {
+        return await fn(server);
+    }
+    finally {
+        server.close();
+    }
+}
+/** Flatten `account/rateLimits/read` into display windows. */
+export function codexUsageWindows(result) {
+    const snapshots = result.rateLimitsByLimitId && Object.keys(result.rateLimitsByLimitId).length
+        ? Object.entries(result.rateLimitsByLimitId) : [['codex', result.rateLimits]];
+    const windows = [];
+    for (const [limitId, snap] of snapshots) {
+        if (!snap)
+            continue;
+        for (const [slot, w] of [['primary', snap.primary], ['secondary', snap.secondary]]) {
+            if (!w || typeof w.usedPercent !== 'number')
+                continue;
+            windows.push({
+                id: `${limitId}:${slot}`,
+                label: `${snap.limitName ?? limitId} · ${windowName(w.windowDurationMins ?? undefined)}`,
+                usedPercent: w.usedPercent,
+                windowMins: w.windowDurationMins ?? undefined,
+                resetsAt: typeof w.resetsAt === 'number' ? new Date(w.resetsAt * 1000).toISOString() : undefined,
+            });
+        }
+    }
+    return windows;
+}
+export function windowName(mins) {
+    if (!mins)
+        return 'window';
+    if (mins === 300)
+        return '5h';
+    if (mins === 10_080)
+        return 'weekly';
+    if (mins % 1440 === 0)
+        return `${mins / 1440}d`;
+    if (mins % 60 === 0)
+        return `${mins / 60}h`;
+    return `${mins}m`;
+}

package/dist/subscriptions/launch.d.ts

@@ -0,0 +1,37 @@
+import { type SubscriptionPin, type SubscriptionProvider } from './store.js';
+/** The subscription provider a harness authenticates with, if Fleet manages it. */
+export declare function providerForHarness(harness: string): SubscriptionProvider | undefined;
+/** Env var that selects the CLI home for each provider. */
+export declare const HOME_ENV: Record<SubscriptionProvider, string>;
+/**
+ * Credential sources that would silently outrank the fleet-wide active profile
+ * (see Claude Code's documented authentication precedence and Codex's
+ * API-key login). While a non-default profile is active they are refused.
+ */
+export declare const CONFLICTING_AUTH_ENV: Record<SubscriptionProvider, string[]>;
+/** Claude managed-settings file (Linux), which outranks user settings. */
+export declare const CLAUDE_MANAGED_SETTINGS = "/etc/claude-code/managed-settings.json";
+/**
+ * Competing Claude credential sources declared in settings files: an `env`
+ * block entry from CONFLICTING_AUTH_ENV, or an `apiKeyHelper`. Settings are
+ * shared into profiles, so they can silently outrank a profile's login.
+ */
+export declare function claudeSettingsAuthSources(home: string, managed?: string): string[];
+export interface LaunchPin {
+    pin: SubscriptionPin;
+    /** Added to the harness child env last. Empty for the adopted default. */
+    env: Record<string, string>;
+    /** Host path the sandbox must mount read-write, if any. */
+    writablePath?: string;
+}
+/**
+ * Resolve the provider's active profile for a launch and record it in the
+ * agent's state dir. Resolution happens once, here: a later switch never
+ * changes what this session uses.
+ */
+export declare function pinSubscriptionForLaunch(role: {
+    name: string;
+    harness: string;
+    env?: Record<string, string>;
+    auth_proxy?: unknown;
+}, stateDir: string, inherited?: NodeJS.ProcessEnv, now?: () => Date): LaunchPin | undefined;