@ours.network/fleet 1.1.5 → 1.2.0-nightly.2

package/README.md

@@ -510,6 +510,23 @@ obsolete, presence-sensitive `OURS_AUTOSTART` variable from ACP harness
 processes. `ours-mcp proxy` is client-only and never starts a daemon; operators and explicit
 installer/setup flows remain responsible for starting it.
 
+Fleet selects explicit `OURS_CONFIG` first, otherwise the managed
+`~/.ours-client/profile.json` when present. With a managed profile, ordinary
+`ours-fleet doctor` and `ours-fleet up` need no environment override. Invalid or
+unreadable managed profiles fail rather than select another daemon. If neither
+selection exists, the existing unmanaged behavior remains.
+
+The private profile names the daemon endpoint, retained instance UUID and host
+credential path; Fleet does not need the daemon state directory. An explicit
+override selects a new invocation without rewriting already installed service
+definitions. To select another profile explicitly:
+
+```sh
+export OURS_CONFIG=/absolute/private/ours/client.json
+ours-fleet doctor
+ours-fleet up
+```
+
 ### Rooms and tasks
 
 Init installs editable `single`, `pair`, and `team` definitions under
@@ -548,7 +565,26 @@ N, Enter, Escape, Ctrl-C, Ctrl-D, or EOF cancels. In a picker, Escape, Ctrl-C, C
 or EOF cancels; Enter records the highlighted choice (or continues a non-empty multi-select),
 N is ignored, and an empty subscription selection remains blocked. Every cancellation
 before the final Yes performs no host setup or config publication. Non-TTY use stops with
-the same zero-mutation guarantee. After the final Yes, host integration runs before locked
+the same zero-mutation guarantee unless `--settings PATH` supplies complete JSON answers.
+Prepared settings run without questions and use this strict shape (catalog model capabilities
+must match exactly):
+
+```json
+{
+  "subscriptions": ["codex"],
+  "assignmentStrategy": "one-model",
+  "models": {
+    "development": { "harness": "codex", "session": "acp", "model": "gpt-5.6-sol", "efforts": ["low", "medium", "high", "xhigh", "max", "ultra"] },
+    "review": { "harness": "codex", "session": "acp", "model": "gpt-5.6-sol", "efforts": ["low", "medium", "high", "xhigh", "max", "ultra"] },
+    "coordination": { "harness": "codex", "session": "acp", "model": "gpt-5.6-sol", "efforts": ["low", "medium", "high", "xhigh", "max", "ultra"] }
+  },
+  "reasoning": "balanced"
+}
+```
+
+Run `ours-fleet init --settings settings.json -c /path/custom.yaml`. Unreadable,
+malformed, incomplete, extra, or unsupported values fail before host setup and publication;
+Fleet never falls back to questions. After the final Yes or validated settings, host integration runs before locked
 publication; a hard kill, power loss, or host crash can therefore leave host integration
 or private stage/recovery evidence to inspect.
 Existing targets and their tree must be owner-private regular files/directories on the
@@ -1610,3 +1646,54 @@ any interpreter symlink path. Declare these installation-specific paths in
 `isolation.fs.read`; do not expose an entire operator home. The tested policy
 allowed a project write and refused a write to an outside read-only directory.
 The `broker` network mode retains host networking; it is not network isolation.
+
+## Container-daemon recovery checks
+
+After building Fleet with the selected SDK and CLI artifacts installed, run
+`npm run test:v1-recovery` in an isolated Docker container with external networking
+disabled. The existing test covers retry and terminal failure cases using a
+temporary daemon and no authenticated AI harness. By default both daemon and
+token-update commands use `node_modules/@ours.network/cli/dist/cli.js`;
+`FLEET_DAEMON_CLI` and `FLEET_TOKEN_CLI` can select explicitly prepared CLI entries.
+These package checks do not replace native Fleet/harness or platform acceptance.
+
+### Build with selected SDK and CLI archives
+
+Run in the build container with Node 22+, npm and tar available:
+
+```sh
+node scripts/build-selected.mjs --sdk /artifacts/ours.network-sdk-3.7.2.tgz --cli /artifacts/ours.network-cli-2.7.2.tgz --out-dir /artifacts/consumer
+```
+
+The recipe validates package names, installs and builds in disposable staging,
+then writes one complete portable npm archive. Stdout is a JSON object with its
+actual `filename`; build/npm logs go to stderr. Normal source manifests, locks
+and installed dependencies are preserved. The installer must install the same
+selected SDK and CLI archives alongside this package; its final dependency
+versions come from those archives. Existing bundling choices are unchanged.
+
+Focused build/install verification (two real builds, including changed bytes
+under identical input names and versions, plus a missing-vendor negative check):
+
+```sh
+node scripts/check-build-selected.mjs --sdk /artifacts/ours.network-sdk-3.7.2.tgz --cli /artifacts/ours.network-cli-2.7.2.tgz
+```
+
+### Remote clients over HTTPS
+
+A client may select an `https://` origin backed by a TLS reverse proxy. Keep the
+daemon listener private and configure the proxy separately with a certificate
+trusted by the client and matching the hostname. Node uses its normal trust
+store; a private CA may be supplied through `NODE_EXTRA_CA_CERTS` before starting
+the client. Certificate verification must remain enabled.
+
+The existing issued client credential works over either transport; changing the
+URL scheme does not require a new credential. Keep the server's master on the
+server. Forward `x-ours-api-token` and the `x-ours-*` session headers unchanged,
+and support streamed request/response bodies and long polling. Client requests
+refuse redirects, including HTTPS-to-HTTP redirects: configure the final HTTPS
+origin directly. UUID/capability checks still precede credential-bearing calls.
+
+This adds client HTTPS support, not an HTTPS daemon listener, certificate
+provisioning or automatic reverse-proxy configuration. Existing local HTTP and
+SSH-tunnel profiles continue to work.

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.1.5",
-  "buildId": "a396a4f22c11",
-  "commit": "9add3db892e29fd3fe0b5d4d44af84617f33d5f7",
-  "dirty": false,
-  "builtAt": "2026-09-11T19:32:31.270Z",
+  "version": "1.2.0-nightly.2",
+  "buildId": "e29dfb038997",
+  "commit": "95f30545961ab68e2196fe3c9b3759ab8319f0ca",
+  "dirty": true,
+  "builtAt": "2026-09-19T07:35:12.185Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -9,7 +9,7 @@ import { Command } from 'commander';
 import { VERSION } from './version.js';
 import { INIT_COMPLETION_GUIDANCE } from './init-guidance.js';
 import { migrateLegacyStarterPresets, migratePackagedRoleDefaults } from './preset-migration.js';
-import { executeInitWizard, isInteractiveTerminal, publishSetup, TerminalPrompter, } from './init-wizard.js';
+import { executeInitAnswers, executeInitWizard, isInteractiveTerminal, publishSetup, readInitSettings, TerminalPrompter, } from './init-wizard.js';
 import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, runningLabel, } from './provenance.js';
 import { agentDir, agentsRoot, tmpRoot, logsRoot, deriveXdgRuntimeDir, defaultConfigPath } from './paths.js';
 import { findRole, loadConfig, ROLE_NAME_RE } from './config.js';
@@ -1269,13 +1269,14 @@ cOpt(program.command('doctor').description('prerequisite report'))
     if (!rep.ok)
         throw new FleetCliExit(1);
 });
-cOpt(program.command('init').description('interactively add missing Fleet defaults while preserving existing configuration'))
+cOpt(program.command('init').description('add missing Fleet defaults while preserving existing configuration')
+    .option('--settings <file>', 'validated InitAnswers JSON; runs without interactive questions'))
     .action(async (opts) => {
     const configuration = opts.configuration ?? defaultConfigPath();
-    if (!isInteractiveTerminal(process.stdin, process.stdout))
+    if (!opts.settings && !isInteractiveTerminal(process.stdin, process.stdout))
         die('ours-fleet init requires an interactive terminal; no host setup ran and no configuration changed');
     try {
-        const result = await executeInitWizard(new TerminalPrompter(process.stdin, process.stdout), configuration, {
+        const initDeps = {
             async hostSetup() {
                 for (const d of [agentsRoot(), tmpRoot(), logsRoot()])
                     mkdirSync(d, { recursive: true });
@@ -1283,10 +1284,13 @@ cOpt(program.command('init').description('interactively add missing Fleet defaul
                     console.log(message);
             },
             publish: publishSetup,
-        });
+        };
+        const result = opts.settings
+            ? await executeInitAnswers(readInitSettings(opts.settings), configuration, initDeps)
+            : await executeInitWizard(new TerminalPrompter(process.stdin, process.stdout), configuration, initDeps);
         if (!result) {
             console.log('Fleet setup cancelled. No host setup ran and no configuration changed.');
-            return;
+            throw new FleetCliExit(1);
         }
         const prior = result.manifestExisted && result.rootExisted ? 'manifest and split configuration'
             : result.manifestExisted ? 'manifest only'
@@ -1297,6 +1301,8 @@ cOpt(program.command('init').description('interactively add missing Fleet defaul
         console.log(INIT_COMPLETION_GUIDANCE);
     }
     catch (error) {
+        if (error instanceof FleetCliExit)
+            throw error;
         die(error);
     }
 });

package/dist/client-profile.d.ts

@@ -0,0 +1,17 @@
+export interface ExplicitClientProfile {
+    readonly endpoint: string;
+    readonly expectedInstanceId: string;
+    readonly credentialPath: string;
+    readonly configPath: 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;
+export declare function clientProfileKey(profile: ExplicitClientProfile): string;

package/dist/client-profile.js

@@ -0,0 +1,115 @@
+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.pathname !== '/'
+        || url.search || url.hash)
+        throw invalid(configPath, 'endpoint must be an HTTP or HTTPS origin');
+    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');
+    return Object.freeze({
+        endpoint: url.origin, expectedInstanceId, credentialPath, configPath,
+    });
+}
+export function clientProfileKey(profile) {
+    return `${profile.endpoint}#${profile.expectedInstanceId}`;
+}

package/dist/creation.js

@@ -4,6 +4,7 @@ import { randomUUID } from 'node:crypto';
 import { attachOursClient, } from '@ours.network/sdk/client';
 import { replaceFileAtomically, withFileLock } from './atomic-file.js';
 import { stateRoot } from './paths.js';
+import { readClientProfile } from './client-profile.js';
 import { buildInfo, UNKNOWN_BUILD } from './provenance.js';
 /**
  * One creation transaction: role name and ours identity reserved together,
@@ -221,12 +222,17 @@ 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 ? {
+            endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken, env: {},
+        } : { env, leaseToken, clientPid: process.pid });
+    };
     const provisioner = {
         async exists(name) {
             try {
-                const client = await attachClient({
-                    env, leaseToken: `ours-fleet-identity-preflight-${process.pid}`, clientPid: process.pid,
-                });
+                const client = await connect(`ours-fleet-identity-preflight-${process.pid}`);
                 const identities = await client.identities();
                 if (!Array.isArray(identities))
                     return 'unknown';
@@ -248,10 +254,7 @@ export function daemonIdentityProvisioner(env = process.env, attachClient = atta
     if (options.createPermanent === false)
         return provisioner;
     provisioner.create = async (name, profile) => {
-        const client = await attachClient({
-            env, leaseToken: `ours-fleet-identity-create-${process.pid}-${randomUUID()}`,
-            clientPid: process.pid,
-        });
+        const client = await connect(`ours-fleet-identity-create-${process.pid}-${randomUUID()}`);
         if (!client.listIdentities || !client.createIdentity || !client.releaseLease)
             throw new Error('the selected ours SDK client cannot create permanent identities');
         try {

package/dist/daemon-recovery.d.ts

@@ -1,3 +1,4 @@
+import { type AttachOursClientOptions, type OursClient } from '@ours.network/sdk/client';
 import { type FetchLike } from './monitor.js';
 export declare const DAEMON_RECOVERY_MAX_ATTEMPTS = 6;
 export declare const DAEMON_RECOVERY_INITIAL_BACKOFF_MS = 1000;
@@ -31,6 +32,7 @@ export type DaemonGenerationObservation = {
 interface GenerationProbeDeps {
     readText?(path: string): string;
     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

package/dist/daemon-recovery.js

@@ -1,7 +1,9 @@
 import { readFileSync, realpathSync } from 'node:fs';
 import { join, resolve } from 'node:path';
-import { createHash } from 'node:crypto';
-import { resolveEndpoint } from './monitor.js';
+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;
 export const DAEMON_RECOVERY_INITIAL_BACKOFF_MS = 1_000;
@@ -50,6 +52,9 @@ function canonical(path, deps) {
  * stale `ready` file can outlive the process that wrote it.
  */
 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 {
@@ -141,6 +146,52 @@ export async function probeDaemonGeneration(fetch, env, deps = {}) {
         },
     };
 }
+/** Container selection uses public SDK reads; daemon paths/PIDs remain opaque metadata. */
+async function probeSelectedDaemon(env, 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 ? {
+            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 });
+        if (info.name !== 'ours' || !positiveInteger(info.pid)
+            || typeof info.stateDir !== 'string' || !info.stateDir)
+            return { state: 'unavailable', reason: 'DAEMON_INFO_INVALID' };
+        const progress = startupProgress(info.startup);
+        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' };
+        const identities = await client.identities();
+        if (!Array.isArray(identities))
+            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_INVALID' };
+        if (!identities.length)
+            return { state: 'unavailable', reason: 'DAEMON_IDENTITIES_NOT_READY' };
+        return { state: 'ready', generation: {
+                bootId: progress.bootId, pid: progress.pid, startedAt: progress.startedAt, stateDir: info.stateDir,
+            } };
+    }
+    catch {
+        // Failed selection, auth or transport is unavailable, never owner death.
+        return { state: 'unavailable', reason: 'DAEMON_SELECTED_PROBE_UNAVAILABLE' };
+    }
+    finally {
+        await client?.close();
+    }
+}
 export class DaemonGenerationObserver {
     current;
     unavailable = false;

package/dist/doctor.js

@@ -11,6 +11,7 @@ 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';
 import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, BIN_NAME, } from './provenance.js';
@@ -34,9 +35,21 @@ function cgroupDelegationDetail() {
 function resolveMonitorProfiles(roles) {
     const profiles = [];
     for (const role of roles.filter(r => r.monitor?.mode === 'fleet')) {
-        const endpoint = resolveEndpoint({ ...process.env, ...(role.env ?? {}) });
+        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] });
+            continue;
+        }
+        const endpoint = resolveEndpoint(env);
         const token = endpoint.headers['x-ours-api-token'];
-        const existing = profiles.find(p => p.endpoint.origin === endpoint.origin
+        const existing = profiles.find(p => p.endpoint?.origin === endpoint.origin
             && p.endpoint.headers['x-ours-api-token'] === token);
         if (existing)
             existing.roles.push(role.name);
@@ -416,12 +429,35 @@ 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 } = profile;
+        const { endpoint, client: selected } = profile;
         const checkName = monitorProfiles.length === 1
             ? 'monitor: daemon API'
             : `monitor: daemon API (${profile.roles.join(', ')})`;
         let ok = false, detail;
         try {
+            if (selected) {
+                const daemon = await attachOursClient({
+                    endpoint: selected.endpoint,
+                    expectedInstanceId: selected.expectedInstanceId,
+                    credentialPath: selected.credentialPath,
+                    sessionMode: 'external', leaseToken: `ours-fleet-doctor-monitor-${process.pid}`,
+                    env: {},
+                });
+                try {
+                    const [info, identities] = await Promise.all([
+                        daemon.version(), daemon.identities(),
+                    ]);
+                    if (info.name !== 'ours' || !Array.isArray(identities))
+                        throw new Error('selected daemon metadata is invalid');
+                    ok = true;
+                    detail = `reachable at ${selected.endpoint}, authorized — supervisor wake stream available`;
+                }
+                finally {
+                    await daemon.close();
+                }
+                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?`;
@@ -440,7 +476,8 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
             }
         }
         catch (e) {
-            detail = `unreachable on :${endpoint.port} — monitored roles run degraded until it is up ` +
+            const target = selected?.endpoint ?? `:${endpoint.port}`;
+            detail = `unreachable on ${target} — monitored roles run degraded until it is up ` +
                 `(start it: ours daemon start) [${e?.message ?? e}]`;
         }
         checks.push({ name: checkName, ok, detail });

package/dist/harness/codex.js

@@ -167,6 +167,10 @@ function codexAgentLaunch(role, prep) {
             ...(options?.search ? ['--search'] : []),
             'app-server',
         ];
+        // Fleet delivers wakes through the native session itself. The ours-codex
+        // launcher owns a remote TUI and cannot serve this stdio transport.
+        if (launcher === 'auto' && role.monitor?.mode === 'fleet')
+            return { argv: ['codex', ...flags], env: prep.env };
         // Preserve the established `auto` launcher contract without resolving PATH
         // during synchronous launch preparation. The static shell fragment passes
         // every dynamic value as an argv element and `exec`s the selected process.

package/dist/init-wizard.d.ts

@@ -42,18 +42,23 @@ export interface InitPublishResult {
     manifestExisted: boolean;
     rootExisted: boolean;
 }
+export interface InitExecutionDeps {
+    hostSetup(): Promise<void>;
+    publish(configuration: string, setup: GeneratedSetup): Promise<InitPublishResult>;
+    generate?(answers: InitAnswers): GeneratedSetup;
+    preflight?(configuration: string): InitPathState;
+}
 export declare function validateCatalog(value: BrainCatalog, path?: string): BrainCatalog;
+/** Read and validate the complete public InitAnswers JSON shape without side effects. */
+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;
 /** 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. */
-export declare function executeInitWizard(prompter: InitPrompter, configuration: string, deps: {
-    hostSetup(): Promise<void>;
-    publish(configuration: string, setup: GeneratedSetup): Promise<InitPublishResult>;
-    generate?(answers: InitAnswers): GeneratedSetup;
-    preflight?(configuration: string): InitPathState;
-}): Promise<InitPublishResult | undefined>;
+export declare function executeInitWizard(prompter: InitPrompter, configuration: string, deps: InitExecutionDeps): Promise<InitPublishResult | undefined>;
+/** Execute already-collected answers through the same validation and mutation boundary. */
+export declare function executeInitAnswers(answers: InitAnswers, configuration: string, deps: InitExecutionDeps): Promise<InitPublishResult>;
 export interface InitPathInspectionDeps {
     exists?(path: string): boolean;
     lstat?(path: string): Stats;

package/dist/init-wizard.js

@@ -49,6 +49,35 @@ function catalog() {
     const path = join(packagedPresetRoot(), 'brain-catalog.json');
     return validateCatalog(JSON.parse(readFileSync(path, 'utf8')), path);
 }
+const hasExactKeys = (value, keys) => Object.keys(value).sort().join('\0') === [...keys].sort().join('\0');
+/** Read and validate the complete public InitAnswers JSON shape without side effects. */
+export function readInitSettings(path) {
+    let value;
+    try {
+        value = JSON.parse(readFileSync(resolve(path), 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`cannot read valid Fleet init settings ${path}: ${error.message}`, { cause: error });
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)
+        || !hasExactKeys(value, ['subscriptions', 'assignmentStrategy', 'models', 'reasoning']))
+        throw new Error('Fleet init settings must contain exactly subscriptions, assignmentStrategy, models, and reasoning');
+    const candidate = value;
+    const models = candidate.models;
+    if (!models || typeof models !== 'object' || Array.isArray(models)
+        || !hasExactKeys(models, WORK_KINDS))
+        throw new Error('Fleet init settings models must contain exactly development, review, and coordination');
+    for (const work of WORK_KINDS) {
+        const model = models[work];
+        if (!model || typeof model !== 'object' || Array.isArray(model)
+            || !hasExactKeys(model, ['harness', 'session', 'model', 'efforts']))
+            throw new Error(`Fleet init settings ${work} model must contain exactly harness, session, model, and efforts`);
+    }
+    const answers = value;
+    // Generation is the single semantic/catalog validator for wizard and file input.
+    generateSetup(answers);
+    return answers;
+}
 const subscriptionFor = (model) => model.harness === 'codex' ? 'codex' : 'claude';
 export async function askInitQuestions(prompter, configuration) {
     const configPath = resolve(configuration);
@@ -216,6 +245,10 @@ export async function executeInitWizard(prompter, configuration, deps) {
     const answers = await askInitQuestions(prompter, configuration);
     if (!answers)
         return undefined;
+    return executeInitAnswers(answers, configuration, deps);
+}
+/** Execute already-collected answers through the same validation and mutation boundary. */
+export async function executeInitAnswers(answers, configuration, deps) {
     // Resolve every catalog/preset dependency before crossing the first mutation
     // boundary. Production owns this new map; the optional seam forces failures
     // deterministically in tests.