@ours.network/fleet 1.2.0-nightly.4 → 1.2.0-nightly.40

package/dist/harness/codex.js

@@ -6,7 +6,7 @@ import { realExec } from '../exec.js';
 import { registerAdapter } from './registry.js';
 import { harnessRuntimeDir } from '../isolation/policy.js';
 import { resolveBundledAcpAgent, } from './acp-agent.js';
-import { VERIFIED_CODEX_ACP_VERSIONS, probeCodexRuntime, codexVersionAtLeast } from './codex-runtime.js';
+import { VERIFIED_CODEX_ACP_VERSIONS, probeCodexRuntime, codexVersionAtLeast, hostCodex } from './codex-runtime.js';
 import { CodexAgentSessionAdapter } from './codex-session.js';
 const OPTION_KEYS = [
     'launcher', 'sandbox', 'approval', 'permission_mode', 'search', 'profile', 'config', 'add_dirs',
@@ -25,12 +25,13 @@ const CODEX_PROXY_REAL_PATH_ENV = 'OURS_FLEET_REAL_CODEX_PATH';
 const CODEX_PROXY_MANIFEST_ENV = 'OURS_FLEET_CODEX_ACP_MANIFEST';
 /**
  * What an unattended role can actually do under Codex's native settings.
- * `on-request` and `untrusted` stop to ask, and with no console attached that
- * request is refused rather than answered — so the role can only read.
+ * `on-request` and `untrusted` can ask even for startup file reads (for example,
+ * shell reads or files outside the sandbox). Without a controller the request
+ * waits or is denied according to policy. Neither guarantees `read-state`.
  */
 export function codexCapabilities(approval, sandbox) {
     if (approval !== 'never')
-        return ['read-state'];
+        return [];
     const caps = ['read-state', 'messaging', 'monitor', 'status-commands'];
     if (sandbox !== 'read-only')
         caps.push('write-state', 'workspace-edit');
@@ -265,7 +266,9 @@ function codexAcpEnvironment(role, dirs) {
         [CODEX_PROXY_APPROVAL_ENV]: approvalPolicy(role) ?? 'on-request',
         [CODEX_PROXY_SANDBOX_ENV]: acpRuntimeSandbox(role),
         [CODEX_PROXY_MANIFEST_ENV]: resolution.manifestPath,
-        [CODEX_PROXY_REAL_PATH_ENV]: role.env?.CODEX_PATH ?? process.env.CODEX_PATH ?? '',
+        // Same choice as probeCodexRuntime: an explicit CODEX_PATH, else a host Codex at least as new as the bundled one.
+        [CODEX_PROXY_REAL_PATH_ENV]: role.env?.CODEX_PATH ?? process.env.CODEX_PATH
+            ?? hostCodex(resolution.manifestPath, { ...process.env, ...role.env }, dirs.runCwd)?.path ?? '',
     };
 }
 function encodeTomlValue(value) {

package/dist/init-wizard.d.ts

@@ -53,6 +53,8 @@ export declare function validateCatalog(value: BrainCatalog, path?: string): Bra
 export declare function readInitSettings(path: string): InitAnswers;
 export declare function askInitQuestions(prompter: InitPrompter, configuration: string): Promise<InitAnswers | undefined>;
 export declare function formatSetupSummary(answers: InitAnswers, configuration: string): string;
+/** The packaged Brain preset for a catalog model at one effort; the same naming the presets are generated with. */
+export declare function brainPresetId(model: Pick<CatalogModel, 'harness' | 'model'>, effort: string): string;
 /** Build the exact, deterministic default experience without writing to disk. */
 export declare function generateSetup(answers: InitAnswers): GeneratedSetup;
 /** Run the mutation boundary only after the complete questionnaire is accepted. */

package/dist/init-wizard.js

@@ -7,13 +7,19 @@ import { packagedPresetRoot } from './preset-bootstrap.js';
 import { listTemplates } from './rooms-tasks/templates.js';
 const WORK_KINDS = ['development', 'review', 'coordination'];
 const ROLE_WORK = {
-    Developer: 'development', Critic: 'review',
+    Developer: 'development', Engineer: 'development', Critic: 'review',
     LocalCoordinator: 'coordination', Coordinator: 'coordination', FleetCoordinator: 'coordination',
 };
 const REASONING_EFFORT = {
     quick: 'low', balanced: 'medium', thorough: 'high',
 };
 const MODEL_LABELS = {
+    'gpt-6.1-sol': 'GPT-6.1 Sol',
+    'gpt-6-sol': 'GPT-6 Sol',
+    'gpt-6-luna': 'GPT-6 Luna',
+    'claude-fable-5-1': 'Claude Fable 5.1',
+    'claude-opus-5-5': 'Claude Opus 5.5',
+    'claude-haiku-4-5-20251001': 'Claude Haiku 4.5',
     'gpt-6-astra': 'GPT-6 Astra',
     'gpt-5.6-sol': 'GPT-5.6 Sol',
     'gpt-5.6-terra': 'GPT-5.6 Terra',
@@ -33,10 +39,10 @@ export function validateCatalog(value, path = 'supported model catalog') {
     for (const model of value.models) {
         if (!['codex', 'claude-code'].includes(model.harness) || model.session !== 'acp'
             || typeof model.model !== 'string' || !MODEL_LABELS[model.model]
-            || !Array.isArray(model.efforts) || model.efforts.length === 0
+            || !Array.isArray(model.efforts)
             || new Set(model.efforts).size !== model.efforts.length
             || model.efforts.some(effort => !['low', 'medium', 'high', 'xhigh', 'max', 'ultra'].includes(effort))
-            || !['low', 'medium', 'high'].every(effort => model.efforts.includes(effort)))
+            || (model.efforts.length > 0 && !['low', 'medium', 'high'].every(effort => model.efforts.includes(effort))))
             throw new Error(`unsupported model state in ${path}`);
         const tuple = `${model.harness}\0${model.session}\0${model.model}`;
         if (tuples.has(tuple))
@@ -90,7 +96,9 @@ export async function askInitQuestions(prompter, configuration) {
         return undefined;
     if (subscriptions.length === 0)
         throw new Error('Select at least one subscription.');
-    const available = catalog().models.filter(model => subscriptions.includes(subscriptionFor(model)));
+    // The wizard assigns low/medium/high; no-effort models remain available as named presets.
+    const available = catalog().models.filter(model => subscriptions.includes(subscriptionFor(model))
+        && model.efforts.length > 0);
     if (!available.length)
         throw new Error('None of the selected subscriptions has a supported model.');
     prompter.note([
@@ -163,7 +171,9 @@ export function formatSetupSummary(answers, configuration) {
         '  One-agent work: one Developer',
         '  Reviewed pair: Developer + independent Critic',
         '  Team: LocalCoordinator + Developer + Critic',
+        '  Gated engineering: Engineer (gate pipeline) + independent Critic',
         '  FleetCoordinator: coordination model',
+        '  Brains: the packaged presets; each prepared agent references the preset of its chosen model',
         '',
         'After the final Yes, Fleet performs host service setup before publishing the complete configuration.',
         'A hard termination after that Yes can leave host integration or private stage/recovery evidence to inspect.',
@@ -172,6 +182,11 @@ export function formatSetupSummary(answers, configuration) {
 function preset(relative) {
     return readFileSync(join(packagedPresetRoot(), 'fleet', relative), 'utf8');
 }
+/** The packaged Brain preset for a catalog model at one effort; the same naming the presets are generated with. */
+export function brainPresetId(model, effort) {
+    return `${model.harness === 'claude-code' ? 'claude' : 'codex'}-${model.model
+        .replace(/^claude-/, '').replace(/\./g, '-').toLowerCase()}-${effort}`;
+}
 /** Build the exact, deterministic default experience without writing to disk. */
 export function generateSetup(answers) {
     const effort = REASONING_EFFORT[answers.reasoning];
@@ -192,6 +207,7 @@ export function generateSetup(answers) {
         '  permissions: { approval: ask, filesystem: workspace, unattended: deny }',
         '',
     ].join('\n'));
+    const assigned = {};
     for (const work of WORK_KINDS) {
         const proposed = answers.models[work];
         if (!proposed || !answers.subscriptions.includes(subscriptionFor(proposed)))
@@ -205,14 +221,14 @@ export function generateSetup(answers) {
             throw new Error(`${work} contains tampered model capabilities`);
         if (!model.efforts.includes(effort))
             throw new Error(`${MODEL_LABELS[model.model]} does not support ${answers.reasoning} reasoning`);
-        files.set(`brains/${work}.yaml`, [
-            `harness: ${model.harness}`,
-            `session: ${model.session}`,
-            `model: ${model.model}`,
-            `effort: ${effort}`,
-            '',
-        ].join('\n'));
+        // The chosen model is assigned by reference to its packaged Brain preset; setup defines no Brain of its own.
+        const id = brainPresetId(model, effort);
+        if (!existsSync(join(packagedPresetRoot(), 'fleet', 'brains', `${id}.yaml`)))
+            throw new Error(`no packaged Brain preset for ${MODEL_LABELS[model.model]} at ${effort} reasoning`);
+        assigned[work] = id;
     }
+    for (const name of readdirSync(join(packagedPresetRoot(), 'fleet', 'brains')).filter(name => name.endsWith('.yaml')).sort())
+        files.set(`brains/${name}`, preset(`brains/${name}`));
     if (answers.assignmentStrategy === 'one-model') {
         const tuples = new Set(WORK_KINDS.map(work => {
             const model = answers.models[work];
@@ -221,23 +237,26 @@ export function generateSetup(answers) {
         if (tuples.size !== 1)
             throw new Error('one-model assignment requires the same exact model for development, review, and coordination');
     }
-    for (const role of ['Coordinator', 'LocalCoordinator', 'Developer', 'Critic']) {
+    for (const role of ['Coordinator', 'LocalCoordinator', 'Developer', 'Engineer', 'Critic']) {
         files.set(`roles/${role}.yaml`, preset(`roles/${role}.yaml`));
         if (role === 'Coordinator')
             continue;
         files.set(`agent_templates/${role}.yaml`, [
             `role: { ref: ${role} }`,
-            `brain: { ref: ${ROLE_WORK[role]} }`,
+            `brain: { ref: ${assigned[ROLE_WORK[role]]} }`,
             'coordinator: FleetCoordinator',
-            'permissions: { approval: ask, filesystem: workspace, unattended: deny }',
+            // Temporary default while the product is being tested: prepared agents work without asking.
+            'permissions: { approval: allow, filesystem: unrestricted, unattended: deny }',
             'monitor: { mode: fleet, interrupt: after_tool }',
             '',
         ].join('\n'));
     }
     files.set('agents/FleetCoordinator.yaml', preset('agents/FleetCoordinator.yaml')
-        .replace('brain: { ref: claude-default }', 'brain: { ref: coordination }'));
-    for (const name of ['single', 'pair', 'team'])
+        .replace('brain: { ref: claude-default }', `brain: { ref: ${assigned.coordination} }`));
+    for (const name of ['single', 'pair', 'team', 'engineering']) {
         files.set(`room_templates/${name}.yaml`, preset(`room_templates/${name}.yaml`));
+        files.set(`room_layouts/${name}.yaml`, preset(`room_layouts/${name}.yaml`));
+    }
     return { files, answers };
 }
 /** Run the mutation boundary only after the complete questionnaire is accepted. */
@@ -385,7 +404,7 @@ function writeStaged(stageManifest, setup) {
         replaceFileAtomically(target, contents, 0o600);
         fsyncPath(target);
     }
-    for (const kind of ['agents', 'agent_templates', 'roles', 'brains', 'room_templates'])
+    for (const kind of ['agents', 'agent_templates', 'roles', 'brains', 'room_templates', 'room_layouts'])
         fsyncPath(join(stageRoot, kind));
     fsyncPath(stageRoot);
     fsyncPath(dirname(stageManifest));
@@ -394,8 +413,8 @@ function validateStaged(stageManifest) {
     const config = loadConfig(stageManifest, { yamlMode: 'strict' });
     const templates = listTemplates(config.roomTemplates ?? {});
     const names = new Set(templates.map(template => template.name));
-    if (!['pair', 'single', 'team'].every(name => names.has(name)))
-        throw new Error('generated setup did not resolve the default single, pair, and team experiences');
+    if (!['pair', 'single', 'team', 'engineering'].every(name => names.has(name)))
+        throw new Error('generated setup did not resolve the default single, pair, team, and engineering experiences');
     for (const template of templates)
         for (const member of template.members)
             if (!config.agentTemplates?.[member.agent_template])

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/minimal-setup.d.ts

@@ -0,0 +1,2 @@
+/** Prepare only the web configuration; App onboarding chooses agents and brains later. */
+export declare function ensureMinimalSetup(configuration: string): Promise<void>;

package/dist/minimal-setup.js

@@ -0,0 +1,44 @@
+import { existsSync, linkSync, mkdirSync, mkdtempSync, renameSync, rmSync, unlinkSync, writeFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { withFileLock } from './atomic-file.js';
+import { loadConfig, splitRootFor } from './config.js';
+import { preflightInitPaths } from './init-wizard.js';
+import { workspaceOwnerInvite } from './paths.js';
+/** Prepare only the web configuration; App onboarding chooses agents and brains later. */
+export async function ensureMinimalSetup(configuration) {
+    const initial = preflightInitPaths(configuration);
+    await withFileLock(join(initial.parent, `.${basename(initial.splitRoot)}.init.lock`), async () => {
+        const selected = preflightInitPaths(configuration);
+        if (selected.manifestExisted) {
+            loadConfig(selected.configPath, { yamlMode: 'strict', deferredOwnerInviteFile: workspaceOwnerInvite() });
+            return;
+        }
+        if (selected.rootExisted)
+            throw new Error('Fleet split configuration exists without its manifest; retain it and recover the existing setup before setting up a tunnel');
+        const stage = mkdtempSync(join(selected.parent, '.fleet-web-setup-'));
+        const manifest = join(stage, 'fleet.yaml');
+        const root = splitRootFor(manifest);
+        let publishedRoot = false;
+        try {
+            mkdirSync(join(root, 'agents'), { recursive: true, mode: 0o700 });
+            writeFileSync(manifest, 'api_version: ours.network/fleet/v2\n', { mode: 0o600, flag: 'wx' });
+            loadConfig(manifest, { yamlMode: 'strict' });
+            if (existsSync(selected.splitRoot) || existsSync(selected.configPath))
+                throw new Error('Fleet setup targets changed; refusing replacement');
+            renameSync(root, selected.splitRoot);
+            publishedRoot = true;
+            // Same-filesystem link publishes without replacing an unexpected manifest.
+            linkSync(manifest, selected.configPath);
+            unlinkSync(manifest);
+            loadConfig(selected.configPath, { yamlMode: 'strict' });
+        }
+        catch (cause) {
+            if (publishedRoot)
+                throw new Error('Minimal Fleet setup stopped after publishing its empty split directory; existing files were retained for recovery', { cause });
+            throw cause;
+        }
+        finally {
+            rmSync(stage, { recursive: true, force: true });
+        }
+    });
+}

package/dist/monitor.d.ts

@@ -88,33 +88,6 @@ export interface MonitorDeps {
  * turns they trigger keep dying.
  */
 export type StatusCause = 'connectivity' | 'delivery' | 'modal' | 'offline' | 'turns-failing' | 'safe-boundary' | 'auth';
-/** Best-effort daemon config (issue #17): the fields the MCP client reads. */
-interface DaemonConfig {
-    apiToken?: string;
-    port?: number;
-    stateDir?: string;
-}
-/**
- * Read the daemon config the way the MCP client does — best-effort. Any missing,
- * malformed, or unreadable config yields `{}` so token resolution falls through
- * (issue #17). Only the well-typed fields we consume are surfaced.
- */
-export declare function readDaemonConfig(env: NodeJS.ProcessEnv): DaemonConfig;
-/**
- * Resolve the daemon API token exactly like the MCP client (issue #17), a 3-step
- * chain: `OURS_API_TOKEN` (trimmed) → config `apiToken` (trimmed) → the 0600 owner
- * token at `<stateDir>/daemon-token`. Never generates a token; a failed read of
- * any source (missing/unreadable) silently falls through to the next.
- */
-export declare function resolveApiToken(env: NodeJS.ProcessEnv, file?: DaemonConfig): string | undefined;
-export interface DaemonEndpoint {
-    origin: string;
-    port: number;
-    configPath: string;
-    stateDir: string;
-    url(name: string): string;
-    headers: Record<string, string>;
-}
 export type IdentityPresence = {
     state: 'present';
     temporary: boolean;
@@ -125,16 +98,12 @@ export type IdentityPresence = {
     state: 'unknown';
     detail: string;
 };
-/** Resolve the daemon endpoint + auth header from env → config → defaults. */
-export declare function resolveEndpoint(env: NodeJS.ProcessEnv, includeToken?: boolean): DaemonEndpoint;
 /**
  * Ask the daemon's authoritative identity index. The notifications endpoint is
  * intentionally unsuitable for lifecycle: it serves an empty 200 page for a
  * valid but missing identity, which made a closed temp identity look healthy.
  */
 export declare function probeIdentityPresence(name: string, fetch: FetchLike, env: NodeJS.ProcessEnv, deps?: IdentityProbeDeps): Promise<IdentityPresence>;
-/** Actionable, secret-free description of every token source for this profile. */
-export declare function authResolutionHint(ep: DaemonEndpoint): string;
 /** Keep only the events whose type the role asked to wake on. */
 export declare function filterEvents(events: NotifyEvent[], wakeSources: string[]): NotifyEvent[];
 /**
@@ -196,8 +165,7 @@ export declare class Monitor {
     private readonly identity;
     private readonly cfg;
     private readonly deps;
-    private readonly ep?;
-    private readonly profile?;
+    private readonly profile;
     private readonly profileKey;
     private readonly monitorLeaseToken;
     private profileClientPromise?;
@@ -263,4 +231,3 @@ export declare class Monitor {
     private writeStatus;
 }
 export declare function createMonitor(o: MonitorOpts): Monitor;
-export {};

package/dist/monitor.js

@@ -1,6 +1,5 @@
 import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { randomUUID } from 'node:crypto';
-import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { attachOursClient } from '@ours.network/sdk/client';
 import { clientProfileKey, readClientProfile, } from './client-profile.js';
@@ -42,124 +41,28 @@ const TURN_OBSERVE_INTERVAL_MS = 1_500;
 const DEFAULT_TURN_FAIL_THRESHOLD = 3; // fallback when the resolved config omits it
 class AuthError extends Error {
 }
-/** Path to the daemon config the MCP client uses: OURS_CONFIG ?? real ~/.ours/config.json. */
-const daemonConfigPath = (env) => env.OURS_CONFIG ?? join(homedir(), '.ours', 'config.json');
-/** Preserve the daemon's legacy env integer semantics: parseInt, invalid → absent. */
-function envInt(env, name) {
-    const raw = env[name];
-    if (raw === undefined)
-        return undefined;
-    const n = parseInt(raw, 10);
-    return Number.isNaN(n) ? undefined : n;
-}
-/**
- * Read the daemon config the way the MCP client does — best-effort. Any missing,
- * malformed, or unreadable config yields `{}` so token resolution falls through
- * (issue #17). Only the well-typed fields we consume are surfaced.
- */
-export function readDaemonConfig(env) {
-    try {
-        const p = JSON.parse(readFileSync(daemonConfigPath(env), 'utf8'));
-        const o = {};
-        if (typeof p.apiToken === 'string' && p.apiToken.trim())
-            o.apiToken = p.apiToken.trim();
-        if (typeof p.port === 'number' && Number.isFinite(p.port))
-            o.port = p.port;
-        if (typeof p.stateDir === 'string')
-            o.stateDir = p.stateDir;
-        return o;
-    }
-    catch {
-        return {};
-    }
-}
-/**
- * Resolve the daemon API token exactly like the MCP client (issue #17), a 3-step
- * chain: `OURS_API_TOKEN` (trimmed) → config `apiToken` (trimmed) → the 0600 owner
- * token at `<stateDir>/daemon-token`. Never generates a token; a failed read of
- * any source (missing/unreadable) silently falls through to the next.
- */
-export function resolveApiToken(env, file = readDaemonConfig(env)) {
-    const e = env.OURS_API_TOKEN?.trim();
-    if (e)
-        return e;
-    if (file.apiToken)
-        return file.apiToken;
-    const sd = env.OURS_STATE_DIR ?? file.stateDir ?? join(homedir(), '.ours');
-    try {
-        const t = readFileSync(join(sd, 'daemon-token'), 'utf8').trim();
-        if (t)
-            return t;
-    }
-    catch { /* missing/unreadable (e.g. cross-user 0600) → fall through */ }
-    return undefined;
-}
-/** Resolve the daemon endpoint + auth header from env → config → defaults. */
-export function resolveEndpoint(env, includeToken = true) {
-    const file = readDaemonConfig(env);
-    const port = envInt(env, 'OURS_PORT') ?? file.port ?? DEFAULT_PORT;
-    const configPath = daemonConfigPath(env);
-    const stateDir = env.OURS_STATE_DIR ?? file.stateDir ?? join(homedir(), '.ours');
-    const token = includeToken ? resolveApiToken(env, file) : undefined;
-    const origin = `http://127.0.0.1:${port}`;
-    return {
-        origin,
-        port,
-        configPath,
-        stateDir,
-        url: (name) => `${origin}/identities/${encodeURIComponent(name)}/notifications`,
-        headers: token ? { 'x-ours-api-token': token } : {},
-    };
-}
 /**
  * Ask the daemon's authoritative identity index. The notifications endpoint is
  * intentionally unsuitable for lifecycle: it serves an empty 200 page for a
  * valid but missing identity, which made a closed temp identity look healthy.
  */
 export async function probeIdentityPresence(name, fetch, env, deps = {}) {
-    const profile = readClientProfile(env);
-    if (profile) {
-        let client;
-        try {
-            client = await (deps.attachClient?.({
-                endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
-                credentialPath: profile.credentialPath,
-                sessionMode: 'external', leaseToken: randomUUID(), env: {},
-            }) ?? attachOursClient({
-                endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
-                credentialPath: profile.credentialPath,
-                sessionMode: 'external', leaseToken: randomUUID(), env: {},
-            }));
-            return classifyIdentityPresence(name, await client.identities());
-        }
-        catch {
-            return { state: 'unknown', detail: 'selected identity index is unavailable' };
-        }
-        finally {
-            await client?.close().catch(() => undefined);
-        }
-    }
-    const ep = resolveEndpoint(env);
-    let response;
+    let client;
     try {
-        response = await fetch(`${ep.origin}/identities`, { headers: ep.headers });
-    }
-    catch (error) {
-        return { state: 'unknown', detail: `identity index unreachable (${msg(error)})` };
-    }
-    if (!response.ok)
-        return {
-            state: 'unknown',
-            detail: response.status === 401
-                ? `daemon rejected the API token (401) — ${authResolutionHint(ep)}`
-                : `identity index returned HTTP ${response.status}`,
+        const profile = readClientProfile(env);
+        const options = {
+            endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath,
+            sessionMode: 'external', leaseToken: randomUUID(), env: {},
         };
-    try {
-        const body = await response.json();
-        return classifyIdentityPresence(name, body.identities);
+        client = await (deps.attachClient?.(options) ?? attachOursClient(options));
+        return classifyIdentityPresence(name, await client.identities());
     }
-    catch (error) {
-        return { state: 'unknown', detail: `identity index response is unreadable (${msg(error)})` };
+    catch {
+        return { state: 'unknown', detail: 'gateway identity index unavailable; check the shared client profile and issued credential' };
+    }
+    finally {
+        await client?.close().catch(() => undefined);
     }
 }
 function classifyIdentityPresence(name, identities) {
@@ -186,12 +89,6 @@ function classifyIdentityPresence(name, identities) {
             stale: found.stale === true,
         };
 }
-/** Actionable, secret-free description of every token source for this profile. */
-export function authResolutionHint(ep) {
-    const tokenPath = join(ep.stateDir, 'daemon-token');
-    return `set OURS_API_TOKEN, set apiToken in ${JSON.stringify(ep.configPath)}, or ensure ` +
-        `${JSON.stringify(tokenPath)} is readable by the fleet supervisor`;
-}
 /** Keep only the events whose type the role asked to wake on. */
 export function filterEvents(events, wakeSources) {
     const set = new Set(wakeSources);
@@ -414,7 +311,6 @@ export class Monitor {
     identity;
     cfg;
     deps;
-    ep;
     profile;
     profileKey;
     monitorLeaseToken = `ours-fleet-monitor-${process.pid}-${randomUUID()}`;
@@ -441,8 +337,7 @@ export class Monitor {
         this.cfg = o.cfg;
         this.deps = o.deps;
         this.profile = readClientProfile(o.deps.env);
-        this.ep = this.profile ? undefined : resolveEndpoint(o.deps.env);
-        this.profileKey = this.profile ? clientProfileKey(this.profile) : this.ep.origin;
+        this.profileKey = clientProfileKey(this.profile);
         this.statusPath = join(o.agentDir, '.monitor-status');
         this.cursorPath = join(o.agentDir, '.notify-cursor');
         this.statePath = join(o.agentDir, '.monitor-state.json');
@@ -470,14 +365,8 @@ export class Monitor {
         }
         catch (e) {
             if (e instanceof AuthError) {
-                if (this.profile) {
-                    this.cursor = null;
-                    this.degrade('auth', e.message);
-                }
-                else {
-                    this.fatal = true;
-                    this.degrade('auth', e.message, 'failed');
-                }
+                this.cursor = null;
+                this.degrade('auth', e.message);
             }
             else {
                 this.cursor = null;
@@ -510,11 +399,6 @@ export class Monitor {
                 catch (e) {
                     if (this.stopped)
                         return;
-                    if (e instanceof AuthError && !this.profile) {
-                        this.fatal = true;
-                        this.degrade('auth', e.message, 'failed');
-                        return;
-                    }
                     backoff = Math.min(backoff + BACKOFF_STEP_MS, BACKOFF_MAX_MS);
                     if (e instanceof AuthError)
                         this.degrade('auth', e.message);
@@ -630,23 +514,19 @@ export class Monitor {
         this.currentAbort = ctrl;
         let timedOut = false;
         const timer = this.deps.timers.set(() => { timedOut = true; ctrl.abort(); }, timeoutMs);
-        let resp;
         try {
-            if (this.profile) {
-                const client = await this.profileClient();
-                const page = await client.readNotificationPage(this.identity, {
-                    since: since === 'tip' ? 'tip' : Number.parseInt(since, 10),
-                    signal: ctrl.signal,
-                    requestTimeoutMs: timeoutMs,
-                });
-                return { cursor: page.cursor, events: page.events };
-            }
-            resp = await this.deps.fetch(`${this.ep.url(this.identity)}?since=${since}`, { headers: this.ep.headers, signal: ctrl.signal });
+            const client = await this.profileClient();
+            const page = await client.readNotificationPage(this.identity, {
+                since: since === 'tip' ? 'tip' : Number.parseInt(since, 10),
+                signal: ctrl.signal,
+                requestTimeoutMs: timeoutMs,
+            });
+            return { cursor: page.cursor, events: page.events };
         }
         catch (error) {
             if (timedOut && timeoutKind === 'stall')
                 throw new Error(`notification stream stalled for ${Math.round(timeoutMs / 1000)}s`);
-            if (this.profile && /(?:HTTP\s*401|unauthori[sz]ed|API token)/i.test(msg(error)))
+            if (/(?:HTTP\s*401|unauthori[sz]ed|API token)/i.test(msg(error)))
                 throw new AuthError(`daemon rejected the API token (401) — verify the credential file `
                     + `${JSON.stringify(this.profile.credentialPath)} selected by `
                     + `${JSON.stringify(this.profile.configPath)}`);
@@ -656,15 +536,8 @@ export class Monitor {
             this.deps.timers.clear(timer);
             this.currentAbort = null;
         }
-        if (resp.status === 401)
-            throw new AuthError(`daemon rejected the API token (401) — ${authResolutionHint(this.ep)}`);
-        if (!resp.ok)
-            throw new Error(`daemon returned HTTP ${resp.status}`);
-        return resp.json();
     }
     profileClient() {
-        if (!this.profile)
-            throw new Error('explicit client profile is not selected');
         if (!this.profileClientPromise) {
             const { endpoint, expectedInstanceId, credentialPath } = this.profile;
             const options = {

package/dist/notifications/fleet-producer.d.ts

@@ -0,0 +1,18 @@
+import { type ProducerConfig } from './outbox.js';
+/** Read durable supervisor ledgers without restarting agents or attaching a
+ * conversation controller. Each tick reads at most 256 KiB per role, from its
+ * checkpoint; it never loads a complete transcript or requests model history. */
+export declare class FleetNotificationProducer {
+    private readonly roots;
+    private readonly stateDir;
+    private readonly config;
+    private readonly warn;
+    private readonly queues;
+    private readonly timer;
+    private readonly existing;
+    constructor(roots: string[], stateDir: string, config: ProducerConfig, warn?: (line: string) => void);
+    private names;
+    poll(): void;
+    drain(): Promise<void>;
+    close(): Promise<void>;
+}