@ours.network/fleet 1.2.0-nightly.14 → 1.2.0-nightly.16

package/README.md

@@ -79,7 +79,7 @@ The state dir contract:
 |---|---|---|
 | Node ≥ 22 | runs `ours-fleet` and its maintained adapters | nodejs.org, `apt`, or `brew` |
 | a harness CLI, logged in | the agent itself | e.g. Claude Code (`claude`) or Codex CLI (`codex`) |
-| `ours` CLI + shared daemon | identity + agent-to-agent messaging | `npm i -g @ours.network/cli@2.8.1-nightly.7 @ours.network/daemon@3.8.1-nightly.1 && ours-daemon start` |
+| `ours` CLI + shared daemon | identity + agent-to-agent messaging | `ours-install client --config /absolute/private/profile.json --integrations fleet --fleet-settings /absolute/fleet-settings.json` |
 
 Linux only: `ours-fleet init` enables *linger* so roles run without a login session
 and survive reboots. macOS: launchd agents start **at login** (no linger
@@ -1348,8 +1348,9 @@ The command override is exact: Fleet does not append `--profile`, `--search`, or
 
 One-off/permanent spawn selects a Brain that owns model, reasoning, native permission,
 sandbox, profile, launcher, search, monitor consent, native config, and additional roots.
-Use `env.OURS_PORT`/`env.OURS_CONFIG` for a
-role-specific ours daemon, or configure the host default in `~/.ours/config.json`.
+All roles use the shared gateway profile `~/.ours-client/profile.json`.
+`OURS_CONFIG` selects an alternate whole profile. Legacy port/token/state-dir
+overrides are rejected. See the [gateway setup guide](https://github.com/adapt-toolkit/ours-network/blob/prerelease/packages/installer/GATEWAY_SETUP.md).
 
 ## Agent isolation
 

package/dist/agent-ours/service.js

@@ -267,8 +267,10 @@ export async function preparePermanentAssignment(role) {
         endpoint: profile.endpoint,
         expectedInstanceId: profile.expectedInstanceId,
         credentialPath: profile.credentialPath,
-        sessionMode: 'local',
-        requiredCapabilities: ['local-pid-v1', 'root-first-identities-v1'],
+        sessionMode: 'external',
+        leaseToken: randomUUID(),
+        requiredCapabilities: ['external-sessions-v1', 'root-first-identities-v1'],
+        env: {},
     });
     try {
         const rows = await client.listIdentities(), row = rows.find((r) => r.name === role.identity);
@@ -295,7 +297,12 @@ export async function preparePermanentAssignment(role) {
         return 'verified';
     }
     finally {
-        await client.close();
+        try {
+            await client.releaseLease();
+        }
+        finally {
+            await client.close();
+        }
     }
 }
 export function readRoomReadiness(roomCid, name) {

package/dist/application/supervisor-ours-tools.js

@@ -71,16 +71,8 @@ export class SupervisorOursTools {
                     verifySelection();
                     return;
                 }
-                const actual = await client.callTool({ name: 'current_identity', arguments: {} });
-                const blocks = actual.content;
-                const lines = blocks?.length === 1 && blocks[0].type === 'text' ? blocks[0].text?.split('\n') : undefined;
-                const prefix = `Bound to "${identity.name}" (${identity.cid})`;
-                const suffix = lines?.[0].startsWith(prefix) ? lines[0].slice(prefix.length) : undefined;
-                const roleSuffix = typeof suffix === 'string' && /^ — role "[^"\r\n]+" under root "[^"\r\n]+"\.$/.test(suffix);
-                const temporaryLine = 'TEMPORARY identity owned by the Fleet supervisor for this logical agent instance. Bridge or harness disconnect retains it; terminal supervisor release deletes local state with best-effort peer notices.';
-                if (actual.isError || !(roleSuffix || (selected.temporary && suffix === '.'))
-                    || (selected.temporary ? lines?.[1] !== temporaryLine : lines?.[1]?.startsWith('TEMPORARY')))
-                    throw new FleetError('capability_unavailable', 'connected supervisor identity does not match legacy ownership proof');
+                // The supervisor owns the binding. The authenticated bridge and pinned local
+                // assignment are authoritative; current_identity is display text, not a protocol.
                 const fresh = legacySupervisorIdentity(role, identityName, selected.temporary, descriptor.generation);
                 if (!('proof' in identity) || fresh.proof !== identity.proof)
                     throw new FleetError('capability_unavailable', 'legacy supervisor identity changed');

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.14",
-  "buildId": "b88d0d158cc7",
-  "commit": "717f6d8a09e6173b9b8a017fc5efb08d71927524",
+  "version": "1.2.0-nightly.16",
+  "buildId": "165e9b4f7cc7",
+  "commit": "6f621eee7791b35ceb6ec72ce7260e288f718002",
   "dirty": true,
-  "builtAt": "2026-09-24T14:15:57.206Z",
+  "builtAt": "2026-09-26T19:18:02.562Z",
   "capabilities": [
     "cowork.http-management-v1",
     "monitor.interrupt.after_tool"

package/dist/client-profile.d.ts

@@ -1,18 +1,6 @@
-export interface ExplicitClientProfile {
-    readonly endpoint: string;
-    readonly expectedInstanceId: string;
-    readonly credentialPath: string;
-    readonly configPath: string;
-    readonly serverUrl?: string;
-}
-export declare class ClientProfileError extends Error {
-    constructor(message: string);
-}
-export declare function clientConfigPath(env: NodeJS.ProcessEnv): string;
-/**
- * Read Fleet's selected host-client profile without opening its credential.
- * A legacy daemon config remains legacy only when none of the profile fields is
- * present. Explicit and managed selections fail closed on invalid input.
- */
-export declare function readClientProfile(env: NodeJS.ProcessEnv): ExplicitClientProfile | undefined;
+import { clientProfilePath, readGatewayClientProfile } from '@ours.network/sdk/client';
+export { ClientProfileError } from '@ours.network/sdk/client';
+export type ExplicitClientProfile = ReturnType<typeof readGatewayClientProfile>;
+export declare const clientConfigPath: typeof clientProfilePath;
+export declare const readClientProfile: typeof readGatewayClientProfile;
 export declare function clientProfileKey(profile: ExplicitClientProfile): string;

package/dist/client-profile.js

@@ -1,130 +1,7 @@
-import { normalizeDaemonEndpoint } from '@ours.network/sdk/client';
-import { lstatSync, readFileSync, statSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { isAbsolute, join } from 'node:path';
-const PROFILE_FIELDS = ['endpoint', 'expectedInstanceId', 'credentialPath'];
-const LOWERCASE_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
-const LEGACY_CONFIG_FIELDS = ['apiToken', 'stateDir', 'port'];
-const LEGACY_ENV_FIELDS = ['OURS_API_TOKEN', 'OURS_STATE_DIR', 'OURS_PORT', 'OURS_DAEMON_ID'];
-export class ClientProfileError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'ClientProfileError';
-    }
-}
-export function clientConfigPath(env) {
-    if (env.OURS_CONFIG !== undefined)
-        return env.OURS_CONFIG;
-    const managedPath = join(env.HOME || homedir(), '.ours-client', 'profile.json');
-    try {
-        lstatSync(managedPath);
-        return managedPath;
-    }
-    catch (error) {
-        if (error.code !== 'ENOENT')
-            throw invalid(managedPath, 'could not be read');
-        return join(homedir(), '.ours', 'config.json');
-    }
-}
-function invalid(path, detail) {
-    return new ClientProfileError(`ours client profile ${JSON.stringify(path)} ${detail}`);
-}
-/**
- * Read Fleet's selected host-client profile without opening its credential.
- * A legacy daemon config remains legacy only when none of the profile fields is
- * present. Explicit and managed selections fail closed on invalid input.
- */
-export function readClientProfile(env) {
-    const configPath = clientConfigPath(env);
-    const managed = configPath === join(env.HOME || homedir(), '.ours-client', 'profile.json');
-    const named = env.OURS_CONFIG !== undefined || managed;
-    let text;
-    try {
-        text = readFileSync(configPath, 'utf8');
-    }
-    catch {
-        if (named)
-            throw invalid(configPath, 'could not be read');
-        return undefined;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(text);
-    }
-    catch {
-        if (named)
-            throw invalid(configPath, 'is not valid JSON');
-        return undefined;
-    }
-    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
-        if (named)
-            throw invalid(configPath, 'must contain a JSON object');
-        return undefined;
-    }
-    const row = parsed;
-    if (!PROFILE_FIELDS.some(field => Object.prototype.hasOwnProperty.call(row, field))) {
-        if (managed)
-            throw invalid(configPath, 'must contain a complete client profile');
-        return undefined;
-    }
-    let metadata;
-    try {
-        metadata = statSync(configPath);
-    }
-    catch {
-        throw invalid(configPath, 'could not be inspected');
-    }
-    if (!metadata.isFile())
-        throw invalid(configPath, 'must be a regular file');
-    const getuid = process.getuid;
-    if (getuid && metadata.uid !== getuid())
-        throw invalid(configPath, 'must be owned by this user');
-    if ((metadata.mode & 0o077) !== 0)
-        throw invalid(configPath, 'must not be accessible by group or other users');
-    for (const field of PROFILE_FIELDS)
-        if (typeof row[field] !== 'string' || !row[field].trim())
-            throw invalid(configPath, `has an invalid or missing ${field}`);
-    for (const field of LEGACY_CONFIG_FIELDS)
-        if (Object.prototype.hasOwnProperty.call(row, field))
-            throw invalid(configPath, `cannot combine ${field} with explicit profile selection`);
-    for (const field of LEGACY_ENV_FIELDS)
-        if (env[field]?.trim())
-            throw invalid(configPath, `cannot combine ${field} with explicit profile selection`);
-    const endpoint = row.endpoint.trim();
-    let url;
-    try {
-        url = new URL(endpoint);
-    }
-    catch {
-        throw invalid(configPath, 'has an invalid endpoint');
-    }
-    if ((url.protocol !== 'http:' && url.protocol !== 'https:') || url.username || url.password
-        || url.search || url.hash)
-        throw invalid(configPath, 'endpoint must be an HTTP or HTTPS base URL');
-    const expectedInstanceId = row.expectedInstanceId.trim();
-    if (!LOWERCASE_UUID.test(expectedInstanceId))
-        throw invalid(configPath, 'expectedInstanceId must be a lowercase UUID');
-    const credentialPath = row.credentialPath.trim();
-    if (!isAbsolute(credentialPath))
-        throw invalid(configPath, 'credentialPath must be absolute');
-    let serverUrl;
-    if (Object.hasOwn(row, 'serverUrl')) {
-        if (typeof row.serverUrl !== 'string' || /[\s\\?#]/.test(row.serverUrl))
-            throw invalid(configPath, 'serverUrl must be a safe HTTP or HTTPS base URL');
-        try {
-            serverUrl = normalizeDaemonEndpoint(row.serverUrl);
-        }
-        catch {
-            throw invalid(configPath, 'serverUrl must be a safe HTTP or HTTPS base URL');
-        }
-        if (normalizeDaemonEndpoint(endpoint) !== serverUrl + '/daemon')
-            throw invalid(configPath, 'endpoint must select serverUrl/daemon');
-    }
-    return Object.freeze({
-        ...(serverUrl === undefined ? {} : { serverUrl }),
-        endpoint: normalizeDaemonEndpoint(endpoint), expectedInstanceId, credentialPath, configPath,
-    });
-}
+import { clientProfilePath, readGatewayClientProfile } from '@ours.network/sdk/client';
+export { ClientProfileError } from '@ours.network/sdk/client';
+export const clientConfigPath = clientProfilePath;
+export const readClientProfile = readGatewayClientProfile;
 export function clientProfileKey(profile) {
     return `${profile.endpoint}#${profile.expectedInstanceId}`;
 }

package/dist/creation.js

@@ -213,10 +213,10 @@ export async function ensureIdentity(name, profile, provisioner, log = () => { }
 export function daemonIdentityProvisioner(env = process.env, attachClient = attachOursClient, options = {}) {
     const connect = (leaseToken) => {
         const profile = readClientProfile(env);
-        return attachClient(profile ? {
+        return attachClient({
             endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
             credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken, env: {},
-        } : { env, leaseToken, clientPid: process.pid });
+        });
     };
     const provisioner = {
         async exists(name) {

package/dist/daemon-recovery.d.ts

@@ -34,14 +34,7 @@ interface GenerationProbeDeps {
     canonicalize?(path: string): string;
     attachClient?(options: AttachOursClientOptions): Pick<OursClient, 'version' | 'identities' | 'close'> | Promise<Pick<OursClient, 'version' | 'identities' | 'close'>>;
 }
-/**
- * Corroborate the loopback daemon's unauthenticated `/info`, its credentialed
- * identity-index readiness route, and its local boot-generation record. The
- * index enforces auth when the daemon visibility requires it; open visibility
- * deliberately does not. No source is sufficient
- * alone: `/info` has no boot id, the identity index has no generation, and a
- * stale `ready` file can outlive the process that wrote it.
- */
+/** Read generation and readiness through the selected gateway. Server paths are opaque. */
 export declare function probeDaemonGeneration(fetch: FetchLike, env: NodeJS.ProcessEnv, deps?: GenerationProbeDeps): Promise<DaemonGenerationProbe>;
 export declare class DaemonGenerationObserver {
     private current?;

package/dist/daemon-recovery.js

@@ -1,8 +1,7 @@
-import { readFileSync, realpathSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import { attachOursClient, } from '@ours.network/sdk/client';
-import { readDaemonConfig, resolveEndpoint } from './monitor.js';
 import { readClientProfile } from './client-profile.js';
 import { replaceFileAtomically } from './atomic-file.js';
 export const DAEMON_RECOVERY_MAX_ATTEMPTS = 6;
@@ -39,129 +38,25 @@ function startupProgress(value) {
         return undefined;
     return row;
 }
-function canonical(path, deps) {
-    const absolute = resolve(path);
-    return deps.canonicalize?.(absolute) ?? realpathSync.native(absolute);
-}
-/**
- * Corroborate the loopback daemon's unauthenticated `/info`, its credentialed
- * identity-index readiness route, and its local boot-generation record. The
- * index enforces auth when the daemon visibility requires it; open visibility
- * deliberately does not. No source is sufficient
- * alone: `/info` has no boot id, the identity index has no generation, and a
- * stale `ready` file can outlive the process that wrote it.
- */
+/** Read generation and readiness through the selected gateway. Server paths are opaque. */
 export async function probeDaemonGeneration(fetch, env, deps = {}) {
-    const profile = readClientProfile(env);
-    if (profile || env.OURS_DAEMON_ID)
-        return probeSelectedDaemon(env, deps, profile);
-    const endpoint = resolveEndpoint(env);
-    let response;
-    try {
-        response = await fetch(`${endpoint.origin}/info`, { headers: endpoint.headers });
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_INFO_UNREACHABLE' };
-    }
-    if (!response.ok)
-        return {
-            state: 'unavailable',
-            reason: response.status === 401 ? 'DAEMON_INFO_UNAUTHORIZED' : 'DAEMON_INFO_HTTP_ERROR',
-        };
-    let info;
-    try {
-        const value = await response.json();
-        if (!value || typeof value !== 'object' || Array.isArray(value))
-            throw new Error('shape');
-        info = value;
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_INFO_INVALID' };
-    }
-    if (info.name !== 'ours' || !positiveInteger(info.pid)
-        || typeof info.stateDir !== 'string' || info.stateDir.length === 0)
-        return { state: 'unavailable', reason: 'DAEMON_INFO_INVALID' };
-    let reportedStateDir;
-    let expectedStateDir;
-    try {
-        reportedStateDir = canonical(info.stateDir, deps);
-        expectedStateDir = canonical(endpoint.stateDir, deps);
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_STATE_DIR_UNAVAILABLE' };
-    }
-    if (reportedStateDir !== expectedStateDir)
-        return { state: 'unavailable', reason: 'DAEMON_STATE_DIR_MISMATCH' };
-    // `/identities` is the daemon's credential-capable readiness route. A
-    // valid-but-empty index is a documented intermediate startup state, never
-    // proof of readiness.
-    let identitiesResponse;
-    try {
-        identitiesResponse = await fetch(`${endpoint.origin}/identities`, { headers: endpoint.headers });
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_UNREACHABLE' };
-    }
-    if (!identitiesResponse.ok)
-        return {
-            state: 'unavailable',
-            reason: identitiesResponse.status === 401
-                ? 'DAEMON_IDENTITIES_UNAUTHORIZED' : 'DAEMON_IDENTITIES_HTTP_ERROR',
-        };
-    try {
-        const body = await identitiesResponse.json();
-        if (!body || typeof body !== 'object' || Array.isArray(body)
-            || !Array.isArray(body.identities))
-            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
-        if (body.identities.length === 0)
-            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_NOT_READY' };
-    }
-    catch {
-        return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
-    }
-    let progress;
     try {
-        const text = deps.readText?.(join(reportedStateDir, 'startup-progress.json'))
-            ?? readFileSync(join(reportedStateDir, 'startup-progress.json'), 'utf8');
-        progress = startupProgress(JSON.parse(text));
+        return await probeSelectedDaemon(deps, readClientProfile(env));
     }
     catch {
-        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_UNAVAILABLE' };
+        return { state: 'unavailable', reason: 'CLIENT_GATEWAY_PROFILE_INVALID' };
     }
-    if (!progress)
-        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_INVALID' };
-    if (progress.phase !== 'ready')
-        return { state: 'unavailable', reason: 'DAEMON_PROGRESS_NOT_READY' };
-    if (progress.pid !== info.pid)
-        return { state: 'unavailable', reason: 'DAEMON_GENERATION_MISMATCH' };
-    return {
-        state: 'ready',
-        generation: {
-            // Keep bootId opaque. Its current writer uses `${pid}-${startedAt}`, but
-            // equality—not its formatting—is the generation contract Fleet needs.
-            bootId: progress.bootId,
-            pid: progress.pid,
-            startedAt: progress.startedAt,
-            stateDir: reportedStateDir,
-        },
-    };
 }
 /** Container selection uses public SDK reads; daemon paths/PIDs remain opaque metadata. */
-async function probeSelectedDaemon(env, deps, profile) {
+async function probeSelectedDaemon(deps, profile) {
     // Defer credential-file access to SDK selection, which checks the configured
     // daemon identity/capability before it reads or sends the credential.
-    const endpoint = profile ? undefined : resolveEndpoint(env, false);
-    const token = profile ? undefined : env.OURS_API_TOKEN?.trim() || readDaemonConfig(env).apiToken;
     let client;
     try {
-        const options = profile ? {
+        const options = {
             endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
             credentialPath: profile.credentialPath,
             sessionMode: 'external', leaseToken: randomUUID(), env: {},
-        } : {
-            endpoint: endpoint.origin, expectedInstanceId: env.OURS_DAEMON_ID,
-            sessionMode: 'external', leaseToken: randomUUID(),
-            ...(token ? { token } : { credentialPath: join(endpoint.stateDir, 'daemon-token') }),
         };
         client = await (deps.attachClient?.(options) ?? attachOursClient(options));
         const info = await client.version({ startup: true });
@@ -189,7 +84,7 @@ async function probeSelectedDaemon(env, deps, profile) {
         return { state: 'unavailable', reason: 'DAEMON_SELECTED_PROBE_UNAVAILABLE' };
     }
     finally {
-        await client?.close();
+        await client?.close().catch(() => undefined);
     }
 }
 export class DaemonGenerationObserver {

package/dist/doctor.d.ts

@@ -3,7 +3,7 @@ import { type Exec } from './exec.js';
 import type { YamlMode } from './config-yaml.js';
 import { type FetchLike } from './monitor.js';
 import type { PrereqReport } from './harness/types.js';
-type DoctorDaemonClient = Pick<OursClient, 'version' | 'close'>;
+type DoctorDaemonClient = Pick<OursClient, 'version' | 'close'> & Partial<Pick<OursClient, 'identities'>>;
 type AttachDoctorDaemon = (options: AttachOursClientOptions) => Promise<DoctorDaemonClient>;
 /** Host-level + per-harness prerequisite report with actionable messages. */
 export declare function doctor(opts?: {

package/dist/doctor.js

@@ -1,5 +1,4 @@
-import { join } from 'node:path';
-import { userInfo, homedir } from 'node:os';
+import { userInfo } from 'node:os';
 import { existsSync, readFileSync } from 'node:fs';
 import { attachOursClient, } from '@ours.network/sdk/client';
 import { realExec } from './exec.js';
@@ -11,7 +10,6 @@ import { agentDir, deriveXdgRuntimeDir } from './paths.js';
 import { resolveIsolation, harnessRuntimeDir } from './isolation/policy.js';
 import { hermesConfiguredProvider } from './harness/hermes-startup.js';
 import { makeBubblewrapBackend } from './isolation/bubblewrap.js';
-import { authResolutionHint, resolveEndpoint, } from './monitor.js';
 import { readClientProfile } from './client-profile.js';
 import { readScheduledLoops, storedLoopHealth } from './loops/state.js';
 import { controlSocketPath } from './session/control.js';
@@ -37,25 +35,21 @@ function resolveMonitorProfiles(roles) {
     const profiles = [];
     for (const role of roles.filter(r => r.monitor?.mode === 'fleet')) {
         const env = { ...process.env, ...(role.env ?? {}) };
-        const client = readClientProfile(env);
-        if (client) {
-            const existing = profiles.find(p => p.client?.endpoint === client.endpoint
-                && p.client.expectedInstanceId === client.expectedInstanceId
-                && p.client.credentialPath === client.credentialPath);
-            if (existing)
-                existing.roles.push(role.name);
-            else
-                profiles.push({ client, roles: [role.name] });
+        let client;
+        try {
+            client = readClientProfile(env);
+        }
+        catch (error) {
+            profiles.push({ roles: [role.name], error: error instanceof Error ? error.message : 'Invalid gateway profile' });
             continue;
         }
-        const endpoint = resolveEndpoint(env);
-        const token = endpoint.headers['x-ours-api-token'];
-        const existing = profiles.find(p => p.endpoint?.origin === endpoint.origin
-            && p.endpoint.headers['x-ours-api-token'] === token);
+        const existing = profiles.find(p => p.client?.endpoint === client.endpoint
+            && p.client.expectedInstanceId === client.expectedInstanceId
+            && p.client.credentialPath === client.credentialPath);
         if (existing)
             existing.roles.push(role.name);
         else
-            profiles.push({ endpoint, roles: [role.name] });
+            profiles.push({ client, roles: [role.name] });
     }
     return profiles;
 }
@@ -156,7 +150,7 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
     // ── Rooms/tasks checks ────────────────────────────────────────
     if (loaded.ok && loaded.rooms) {
         const rooms = loaded.rooms;
-        // Cowork socket reachability
+        // Cowork gateway reachability
         const coworkConfig = rooms.cowork?.config;
         try {
             const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
@@ -165,14 +159,14 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
             checks.push({
                 name: 'cowork', ok: reachable,
                 detail: reachable
-                    ? 'management socket reachable'
-                    : `management socket unreachable${coworkConfig ? ` (config: ${coworkConfig})` : ''}`,
+                    ? 'gateway management reachable'
+                    : `gateway management unreachable${coworkConfig ? ` (config: ${coworkConfig})` : ''}`,
             });
         }
         catch (e) {
             checks.push({
                 name: 'cowork', ok: false,
-                detail: `management socket error${coworkConfig ? ` (config: ${coworkConfig})` : ''}: ${e?.message ?? e}`,
+                detail: `gateway management error${coworkConfig ? ` (config: ${coworkConfig})` : ''}: ${e?.message ?? e}`,
             });
         }
         // Owner CID shape
@@ -219,17 +213,6 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                     : `template '${defaultTemplate}' not found`,
             });
         }
-        // Shared-daemon selection coherence
-        if (rooms.cowork?.config) {
-            const { existsSync: exists } = await import('node:fs');
-            const configOk = exists(rooms.cowork.config);
-            checks.push({
-                name: 'rooms: cowork config', ok: configOk,
-                detail: configOk
-                    ? `cowork config at ${rooms.cowork.config}`
-                    : `cowork config not found: ${rooms.cowork.config}`,
-            });
-        }
         // Hard room-management capability check
         try {
             const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
@@ -273,20 +256,17 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
         }
         catch { /* state dir may not exist yet */ }
     }
-    let managedSelection = false;
+    let managedSelection = true;
     try {
         // Mark explicit selection before validation so a damaged managed profile does
         // not produce advice to start an unrelated local daemon.
-        managedSelection = process.env.OURS_CONFIG !== undefined
-            || existsSync(join(process.env.HOME || homedir(), '.ours-client', 'profile.json'));
+        managedSelection = true;
         const selected = readClientProfile(process.env);
         managedSelection = selected !== undefined;
-        const client = await attachDaemon(selected ? {
+        const client = await attachDaemon({
             endpoint: selected.endpoint, expectedInstanceId: selected.expectedInstanceId,
             credentialPath: selected.credentialPath, env: {}, sessionMode: 'external',
             leaseToken: `ours-fleet-doctor-${process.pid}`,
-        } : {
-            env: process.env, leaseToken: `ours-fleet-doctor-${process.pid}`, clientPid: process.pid,
         });
         let daemonVersion;
         try {
@@ -448,14 +428,18 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
     // shared-mode misconfig (401) surfaces here rather than as a silent deaf monitor.
     const monitorProfiles = resolveMonitorProfiles(roles);
     for (const profile of monitorProfiles) {
-        const { endpoint, client: selected } = profile;
+        const selected = profile.client;
         const checkName = monitorProfiles.length === 1
             ? 'monitor: daemon API'
             : `monitor: daemon API (${profile.roles.join(', ')})`;
-        let ok = false, detail;
+        let ok = false, detail = 'gateway profile unavailable';
+        if (profile.error) {
+            checks.push({ name: checkName, ok: false, detail: profile.error });
+            continue;
+        }
         try {
             if (selected) {
-                const daemon = await attachOursClient({
+                const daemon = await attachDaemon({
                     endpoint: selected.endpoint,
                     expectedInstanceId: selected.expectedInstanceId,
                     credentialPath: selected.credentialPath,
@@ -464,7 +448,7 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 });
                 try {
                     const [info, identities] = await Promise.all([
-                        daemon.version(), daemon.identities(),
+                        daemon.version(), daemon.identities?.(),
                     ]);
                     if (info.name !== 'ours' || !Array.isArray(identities))
                         throw new Error('selected daemon metadata is invalid');
@@ -477,27 +461,11 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 checks.push({ name: checkName, ok, detail });
                 continue;
             }
-            const live = await fetchImpl(`${endpoint.origin}/state-dir`, {});
-            if (!live.ok) {
-                detail = `daemon on :${endpoint.port} answered /state-dir with HTTP ${live.status} — not the ours daemon?`;
-            }
-            else {
-                const auth = await fetchImpl(`${endpoint.origin}/identities`, { headers: endpoint.headers });
-                if (auth.status === 401)
-                    detail = `reachable on :${endpoint.port} but the API token was rejected (401) — ` +
-                        authResolutionHint(endpoint);
-                else if (!auth.ok)
-                    detail = `reachable on :${endpoint.port} but /identities returned HTTP ${auth.status}`;
-                else {
-                    ok = true;
-                    detail = `reachable on :${endpoint.port}, authorized — supervisor wake stream available`;
-                }
-            }
         }
         catch (e) {
-            const target = selected?.endpoint ?? `:${endpoint.port}`;
+            const target = selected.endpoint;
             detail = `unreachable on ${target} — monitored roles run degraded until it is up ` +
-                `(start it: ours-daemon start) [${e?.message ?? e}]`;
+                `(check the configured gateway and issued credential) [${e?.message ?? e}]`;
         }
         checks.push({ name: checkName, ok, detail });
     }