@ours.network/install 1.2.1-nightly.1 → 1.2.1-nightly.2

package/README.md

@@ -1,141 +1,59 @@
-# @ours.network/install — `ours-install`
+# @ours.network/install — one installer for the whole stack
 
-The all-in-one installer for the ours.network stack. One run installs and
-configures the shared daemon, MCP adapter, cowork, Telegram connector, Fleet,
-and plugins for every safely detected agent harness.
+Requires Node.js 22+ and npm. Install the selected release channel:
 
 ```sh
-npm install --global @ours.network/install
+npm install -g @ours.network/install@nightly
 ours-install
 ```
 
-### Stable and nightly channels
-
-Installing `@ours.network/install@latest` selects the stable channel; installing
-`@ours.network/install@nightly` selects the nightly channel. Before changing the
-machine, the installer resolves `@ours.network/mcp`,
-`@ours.network/claude-code`, and `@ours.network/codex`, verifies that their
-selected dist-tags expose one exact lockstep version, and fails closed if they
-do not. MCP and the Codex launcher are installed by exact version, and local
-Claude Code and Codex marketplace manifests pin the corresponding plugin
-packages to that same version.
-
-`OURS_CHANNEL=latest|nightly` (or the legacy `OURS_INSTALL_CHANNEL`) remains an
-explicit override. Without an override, the installed package's own version
-selects the channel.
-
-The normal flow uses one daemon at `~/.ours` on port 3050, shows an eight-stage
-progress bar, and asks only for information it cannot safely infer (normally the
-Human identity's display name). Existing daemon conflicts and moving a Telegram
-connector from another daemon still require explicit confirmation.
-
-## What the installer does
-
-- Installs `@ours.network/cli`, `@ours.network/mcp`,
-  `@ours.network/tg-connector`, `@ours.network/cowork`, and
-  `@ours.network/fleet` on one release channel.
-- Configures, starts, and enables the single shared daemon with a CLI-managed
-  user systemd service on Linux or LaunchAgent on macOS.
-- Creates the daemon's Human identity (historically called the root identity),
-  or preserves the existing one on a re-run.
-- Installs the ours plugin into safely detected Claude Code, Codex, and Hermes
-  installations.
-- Configures and starts cowork as a durable shim over the shared daemon.
-- Configures and starts Telegram as a durable shim over the same daemon.
-- Runs Fleet's native initialization through prepared settings or its interactive wizard. Fleet owns and
-  publishes its v2 configuration, including subscriptions, models, roles,
-  templates, and permissions. The installer does not start Fleet roles.
-
-The operator CLI owns daemon configuration, lifecycle, and boot persistence.
-The MCP package is only the stdio adapter spawned by agent harnesses; the
-installer never asks `ours-mcp` to start a daemon.
-
-Daemon state is temporarily scoped to its package major version. On a same-major
-update, the installer refreshes the packages and runs `ours daemon restart`; the
-CLI streams structured startup phases until restore is complete instead of
-appearing to hang. A different-major update is detected before package
-replacement. The installer explains the incompatibility and, only in an
-interactive run, offers to stop the CLI-managed daemon, copy the complete state
-directory to a timestamped directory under `~/.ours-backups/`, remove the
-managed service and old state, then initialize the new major. The default answer is no, and
-`OURS_ASSUME_YES` never authorizes this purge.
-
-## What remains stopped
-
-Only Fleet is intentionally not started. Review and activate it when ready:
+With no arguments, the console form collects the installation choices: server
+and clients (default), runtime mode, installation directory, install/update,
+Human identity name, ports, client integrations and Fleet settings. Linux x64
+recommends native mode; macOS and Windows recommend Docker. On Windows run the
+installer inside WSL with Docker Desktop integration. This recommendation concerns
+packaging and isolation, not a guarantee that emulated x64 is faster on ARM Macs.
 
-```sh
-# After completing Fleet's wizard and reviewing ~/fleet.yaml:
-ours-fleet doctor
-ours-fleet config
-ours-fleet up
-ours-fleet ls
-```
-
-The final installer screen repeats these commands and provides a copy-paste
-prompt for Claude Code, Codex, or Hermes. The agent should guide local bot-token
-entry without asking the user to paste the secret into chat.
-
-## Preview and automation
+The same installer accepts complete CLI presets. It reports missing answers before
+changing the machine and never opens hidden prompts when arguments are supplied.
+Both forms show the same preparation, identity, update and readiness progress.
 
 ```sh
-ours-install --dry-run
-OURS_ASSUME_YES=1 ours-install
-ours-install --state-dir /absolute/path --port 3070
+# Whole stack, with prepared Fleet settings and no interactive prompts:
+ours-install --mode docker --state-dir "$HOME/ours-docker" \
+  --identity-name "Your Name" --integrations codex,fleet \
+  --fleet-settings "$HOME/fleet-settings.json"
+
+# Native server only; native and packages mean the same mode:
+ours-install server --mode native --state-dir "$HOME/ours-native" \
+  --identity-name "Your Name"
+
+# Clients connected to an existing server:
+ours-install client --config /private/client/profile.json \
+  --integrations codex,fleet --fleet-settings /private/fleet-settings.json
+
+# Update a retained complete installation and its clients:
+ours-install all update --mode docker --state-dir "$HOME/ours-docker" \
+  --identity-name "Your Name" --integrations codex,fleet \
+  --fleet-settings "$HOME/fleet-settings.json" --compatible
 ```
 
-Dry-run walks the real plan without writing files, installing packages, starting
-processes, or changing services. `OURS_ASSUME_YES=1` uses the OS username for a
-new Human identity and asks no ordinary setup questions, but it never bypasses
-selection conflicts, connector moves, or destructive safeguards.
-
-A non-default daemon must be selected coherently with a config file or matching
-port and state directory. Hermes and the generated Fleet role persist that
-selection through `OURS_CONFIG`. Claude Code and Codex plugin registrations
-cannot store an environment value; for those harnesses the installer prints the
-exact `export OURS_CONFIG=...` line that must be added to the shell profile
-before starting the harness. There is no per-application daemon.
-
-`OURS_CONFIG` may also name a prepared private host profile containing the
-complete `endpoint`, `expectedInstanceId`, and absolute `credentialPath` tuple.
-The profile and credential must already be regular current-user files with
-private permissions. In this mode the installer verifies `/selection` before
-sending the credential to `/version`, installs only MCP, detected Claude/Codex
-plugins, and Fleet client support, and never creates, starts, stops, or services
-a host daemon. Telegram, cowork, messenger, daemon voice, and daemon state stay
-Compose-owned. If `OURS_CONFIG` is unset, the same profile is discovered at
-`~/.ours/config.json`; a legacy config there keeps the existing local behavior.
-
-## Uninstall
-
-```sh
-ours-uninstall --state-dir "$HOME/.ours"
-ours-uninstall --state-dir "$HOME/.ours" --purge
-```
-
-The uninstaller delegates service and daemon removal to the `ours` CLI. Identity
-state is retained by default. Purging requires the existing destructive gates and
-targets only the explicit state directory.
-
-When `OURS_CONFIG` selects a host profile, uninstall removes only selected
-client attachments. The operator-owned profile and shared credential are kept
-even with `--purge`, and no Compose daemon, service, or state is touched.
-
-## Release channel
-
-`OURS_CHANNEL=nightly` (or `OURS_INSTALL_CHANNEL`) selects the packages' nightly
-dist-tags. Without an override, the installer's own version selects the channel.
-The operator CLI intentionally has no nightly dist-tag and remains untagged on
-both channels.
+`server` and `client` are presets of the same flow, not separate interactive
+installers. `--integrations none` explicitly skips client integrations. Use
+`--dry-run` with a complete preset to preview it, and `--help` for all options.
+Fleet's own wizard is available only in interactive setup; CLI Fleet setup requires
+its JSON settings file. Fleet stays stopped until you review and activate it.
 
-## Environment
+The server installs the daemon/SDK/CLI, main MCP, Telegram, Cowork and Messenger.
+It starts the daemon, preserves the existing Human identity (or creates it once),
+then starts its applications. Full-stack setup issues a separate local client
+credential and configures the selected Codex, Claude Code and Fleet integrations.
+Existing identity keys and names are retained on update. An update's storage
+compatibility must be reviewed before supplying `--compatible`.
 
-- `OURS_ASSUME_YES=1`: accept safe defaults without prompting.
-- `OURS_INSTALL_DRY_RUN=1`: preview without mutation.
-- `OURS_NPM`: npm executable.
-- `OURS_CONFIG`: explicit legacy daemon config or prepared private host profile.
-- `OURS_STATE_DIR`: explicit daemon state directory.
-- `OURS_CHANNEL`: `latest` or `nightly`.
+The installer embeds exact component versions and SHA-512 values for its release.
+An existing server's retained release selects matching local clients. Secrets are
+read from protected files, and client setup never copies the daemon API master.
 
 ## Selected network installations (2.0)
 
@@ -145,8 +63,8 @@ SHA-512 values. Acquisition validates the ours dependency graph before activatio
 A development override without a release binding is not a qualified product release.
 
 ```sh
-ours-install server install --mode docker --state-dir /private/ours-install
-ours-install server install --mode packages --state-dir /private/ours-install
+ours-install server install --mode docker --state-dir /private/ours-install --identity-name "Your Name"
+ours-install server install --mode packages --state-dir /private/ours-install --identity-name "Your Name"
 ours-install server status --state-dir /private/ours-install
 ours-install server stop --state-dir /private/ours-install
 ours-install server start --state-dir /private/ours-install
@@ -169,6 +87,17 @@ Linux/WSL or a launchd GUI user domain on macOS. Source builds also require Git,
 Python 3, a C/C++ toolchain, make, and the selected repositories' own prerequisites.
 Docker mode requires a working Docker engine and Compose 2.35+; its build image
 contains the source-build prerequisites. No bind or Docker socket mounts are used.
+Docker is recommended for macOS and Windows. Install and start Docker Desktop
+on those hosts; on Linux, install Docker Engine and the Compose plugin. If Docker
+is unavailable, the installer explains how to install/start it or use
+`server install --mode packages --state-dir <new-empty-directory>` instead.
+Native Windows installations require WSL with a working systemd user manager.
+The installer never switches an existing installation's mode automatically.
+Server installation shows each stage before it starts, streams Docker builds and
+native package acquisition, and reports completion only after service readiness.
+If a Docker service fails, the error includes its last 50 log lines (bounded in
+size) and a command to inspect the logs. A failed daemon prevents consumers from
+starting; a failed consumer does not prevent checks of unrelated consumers.
 Server runtime installation selects SDK/CLI, main MCP, Telegram, Cowork and
 Messenger. Main MCP is injected into the daemon, not started as a second daemon.
 The daemon starts first; consumers are checked through their owning readiness
@@ -219,7 +148,7 @@ client-owned installer settings:
 ```
 
 ```sh
-ours-install client install --config /private/client/profile.json
+ours-install client install --config /private/client/profile.json --integrations codex,claude-code
 ```
 
 Optional `sourcesPath` and `fleetSettingsPath` values are absolute or resolved
@@ -269,7 +198,7 @@ For a managed server, maintenance runs on the server machine through the install
 ours-install server backup server snapshot --state-dir /path/to/installation
 ours-install server restore server snapshot --state-dir /path/to/installation
 ours-install server rebuild --state-dir /path/to/installation
-ours-install server update --state-dir /path/to/installation --compatible
+ours-install server update --mode docker --state-dir /path/to/installation --identity-name "Your Name" --compatible
 ```
 
 Backup and restore support the full server or an individual `daemon`, `telegram`,

package/assets/release.json

@@ -1,7 +1,7 @@
 {
   "schema": 1,
   "channel": "nightly",
-  "installerVersion": "1.2.1-nightly.1",
+  "installerVersion": "1.2.1-nightly.2",
   "packages": {
     "@ours.network/sdk": {
       "version": "3.8.1-nightly.3",

package/assets/sources.json

@@ -2,7 +2,7 @@
   "release": {
     "schema": 1,
     "channel": "nightly",
-    "installerVersion": "1.2.1-nightly.1",
+    "installerVersion": "1.2.1-nightly.2",
     "packages": {
       "@ours.network/sdk": {
         "version": "3.8.1-nightly.3",

package/install.mjs

@@ -3,14 +3,14 @@
 import { readFileSync } from 'node:fs';
 
 import { realEffects } from './lib/effects.mjs';
-import { runInstall } from './lib/orchestrate.mjs';
+import { runSetup } from './lib/setup.mjs';
 import { closeSync, makeWriter, openTty } from './lib/ui.mjs';
 
 const version = JSON.parse(readFileSync(new URL('./package.json', import.meta.url), 'utf8')).version;
 const ttyFd = openTty();
 
 try {
-  const code = await runInstall(process.argv.slice(2), realEffects({
+  const code = await runSetup(process.argv.slice(2), realEffects({
     write: makeWriter(ttyFd),
     ttyFd,
     env: process.env,

package/lib/build-transition.mjs

@@ -2,10 +2,16 @@ import { readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { join } from 'node:path';
 import { validateInstallation } from './plan.mjs';
+import { info, ok, warn } from './ui.mjs';
 
 /** The caller holds the installation lock; installation.json owns retry state. */
 export async function serverBuildTransition(record, args, effects) {
   validateInstallation(record, record.root);
+  const stage = async (label, action) => {
+    effects.out?.(info(label));
+    try { const result = await action(); effects.out?.(ok(`${label} complete`)); return result; }
+    catch (error) { effects.out?.(warn(`Server ${args.operation} stopped during ${label.toLowerCase()}.`)); throw error; }
+  };
   const path = join(record.root, 'installation.json');
   const save = transition => {
     record = { ...record, buildTransition: transition };
@@ -14,9 +20,9 @@ export async function serverBuildTransition(record, args, effects) {
   };
   let transition = record.buildTransition;
   if (!transition) {
-    const candidate = await effects.prepareServerBuild(record, args);
+    const candidate = await stage('Prepare the updated runtime', () => effects.prepareServerBuild(record, args));
     try {
-      await effects.checkServerBuild(record, candidate, !!args.compatible, args.operation);
+      await stage('Verify package and stored-state compatibility', () => effects.checkServerBuild(record, candidate, !!args.compatible, args.operation));
       transition = { operation: args.operation, candidate, compatible: !!args.compatible,
         ...(args.sources ? { sourcePolicyHash: createHash('sha256').update(readFileSync(args.sources)).digest('hex') } : {}),
         runningServices: await effects.serverLifecycle(record, 'status'), phase: 'prepared' };
@@ -34,19 +40,19 @@ export async function serverBuildTransition(record, args, effects) {
   const { candidate, runningServices } = transition;
   // A failed readiness check can leave some new services running. Every retry
   // excludes those writers again and retains the original requested running set.
-  await effects.retireServerBuildRuntime(record);
+  await stage('Stop services before updating stored state', () => effects.retireServerBuildRuntime(record));
   if (transition.phase === 'prepared') {
-    await effects.updateServerBuildState(record, candidate, transition.compatible, transition.operation);
+    await stage('Update stored state while retaining identities and credentials', () => effects.updateServerBuildState(record, candidate, transition.compatible, transition.operation));
     transition = { ...transition, phase: 'state-updated' };
     save(transition);
   }
   if (transition.phase === 'state-updated') {
-    await effects.publishServerBuild(record, candidate);
+    await stage('Activate the prepared runtime', () => effects.publishServerBuild(record, candidate));
     transition = { ...transition, phase: 'runtime-activated' };
     save(transition);
   }
-  await effects.validateServerBuildState(record);
-  await effects.serverLifecycle(record, 'start', runningServices);
+  await stage('Verify retained state and identities', () => effects.validateServerBuildState(record));
+  await stage('Restore previously running services and check readiness', () => effects.serverLifecycle(record, 'start', runningServices));
   const completed = { ...record, sourcePolicyHash: candidate.sourcePolicyHash };
   delete completed.buildTransition;
   effects.writeJson(path, JSON.stringify(completed, null, 2) + '\n');

package/lib/effects.mjs

@@ -13,12 +13,13 @@
 
 import { spawnSync, execFileSync } from 'node:child_process';
 import { chmodSync, closeSync, constants, cpSync, existsSync, fstatSync, lstatSync, openSync, readFileSync, mkdirSync, mkdtempSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
-import { homedir, userInfo, platform as osPlatform, release as osRelease } from 'node:os';
+import { homedir, userInfo, platform as osPlatform, release as osRelease, arch as osArch } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { randomUUID, createHash } from 'node:crypto';
 import { dirname, join, resolve } from 'node:path';
 import { maintenanceServices, installationPaths, validateInstallation, consumerServiceState, unitNameForStateDir, launchdLabelForStateDir, messengerServicePlan, selectSourcePackages, resolveSourcePolicy, SERVER_SERVICES } from './plan.mjs';
 import { validateHostProfile } from './target.mjs';
+import { createServerOnboarding } from './server-onboarding.mjs';
 import { atomicWriteConfig, snapshotConfig, restoreConfig } from './config.mjs';
 import { askYesNo, askLine as askLineOnTty } from './prompt.mjs';
 import { classifyHarnessProbe } from './logic.mjs';
@@ -333,7 +334,7 @@ export function realEffects({ write, ttyFd, env = process.env, home = homedir(),
     version,
     interactive: ttyFd != null,
     // Preflight reads the machine rather than asking the orchestrator to.
-    platform: { platform: osPlatform(), release: osRelease() },
+    platform: { platform: osPlatform(), release: osRelease(), arch: osArch() },
     nodeVersion: process.versions.node,
     exists: (path) => existsSync(path),
     knownStateDirs: () => knownStateDirsIn(home),
@@ -413,7 +414,12 @@ export function realEffects({ write, ttyFd, env = process.env, home = homedir(),
         stdio: [...(stream ? ['ignore', 'inherit', 'inherit'] : ['ignore', 'pipe', 'pipe']), ...(installationLockFd === null ? [] : [installationLockFd])],
         env: childEnv,
       });
-      if (r.error || (r.status !== 0 && !allowCodes.includes(r.status))) {
+      if (r.error) {
+        const error = new Error(`${executable} could not start (${r.error.code ?? 'launch error'})`, { cause: r.error });
+        error.code = r.error.code;
+        throw error;
+      }
+      if (r.status !== 0 && !allowCodes.includes(r.status)) {
         const detail = sensitive ? '' : (r.stderr || r.stdout || '').trim().split('\n').slice(-3).join('; ');
         throw new Error(`${executable} ${args.join(' ')} exited ${r.status}${detail ? `: ${detail}` : ''}`);
       }
@@ -533,12 +539,30 @@ export function networkEffects(effects) {
     OURS_MESSENGER_PORT: String(record.messengerPort ?? 8420),
     OURS_MESSENGER_IDENTITY: record.messengerIdentity ?? '',
   });
-  const compose = (record, args, options = {}) => effects.run('docker', [
+  const composeArgs = (record, args) => [
     'compose', '--project-directory', record.workDir, '--file', join(record.workDir,
       record.schema === 1 && existsSync(join(record.workDir, 'docker-compose.legacy.yaml'))
         ? 'docker-compose.legacy.yaml' : 'docker-compose.yaml'),
     '--project-name', record.project, ...args,
-  ], { ...options, env: { ...baseEnv(record), ...options.env } });
+  ];
+  const compose = (record, args, options = {}) => effects.run('docker', composeArgs(record, args),
+    { ...options, env: { ...baseEnv(record), ...options.env } });
+  const dockerStartupError = async (record, service, cause) => {
+    const args = ['logs', '--no-color', '--tail', '50', '--timestamps', service];
+    const quote = value => `'${String(value).replaceAll("'", "'\\''")}'`;
+    const command = `OURS_DAEMON_ID=${quote(record.instanceId)} docker ${composeArgs(record, args).map(quote).join(' ')}`;
+    let detail;
+    try {
+      const logs = await compose(record, args);
+      // Limit terminal diagnostics; container output must not inject terminal controls.
+      detail = (logs.stdout ?? '').replace(/\x1b\[[0-?]*[ -/]*[@-~]/g, '')
+        .replace(/[\x00-\x08\x0b-\x1f\x7f]/g, '').trim().slice(-6000);
+      detail = detail ? `Recent ${service} logs:\n${detail}` : 'The container produced no readable logs.';
+    } catch {
+      detail = 'Container logs could not be read.';
+    }
+    return new Error(`Docker service "${service}" failed to start or become healthy.\n${detail}\nStartup error: ${cause.message}\nInspect logs: ${command}`, { cause });
+  };
   const bin = (record, name) => join(record.workDir, 'node_modules', '.bin', name);
   const localEnv = (record, service = 'daemon') => {
     const paths = installationPaths(record);
@@ -566,6 +590,7 @@ export function networkEffects(effects) {
     }
   };
   return {
+    ...createServerOnboarding(effects, { compose, localEnv, bin }),
     sourcePolicyHash(path) {
       return createHash('sha256').update(readFileSync(path)).digest('hex');
     },
@@ -601,7 +626,7 @@ export function networkEffects(effects) {
       const project = `ours-${createHash('sha256').update(root).digest('hex').slice(0, 16)}`;
       return { schema: 2, root, mode, instanceId, project, workDir: join(root, 'runtime'), configPath: installationPaths({ schema: 2, root }).config, sourcesPath: join(root, 'sources.json'), services: [...SERVER_SERVICES], port: 3050, coworkPort: 3052, messengerPort: 8420, messengerIdentity: env.OURS_MESSENGER_IDENTITY || null, uid: 1000, gid: 1000 };
     },
-    async serverPreflight(record, operation, { existing, sourcePath = record.sourcesPath, sourceManifest } = {}) {
+    async serverPreflight(record, operation, { existing, sourcePath = record.sourcesPath, sourceManifest, identityName } = {}) {
       if (existing) {
         privateDirectory(record.root);
         assertPrivateRegularFile(join(record.root, 'installation.json'), 'selection');
@@ -609,10 +634,34 @@ export function networkEffects(effects) {
         if (env.OURS_DAEMON_ID && env.OURS_DAEMON_ID !== record.instanceId) throw new Error('Conflicting instance ID');
       }
       if (record.mode === 'docker') {
-        await effects.run('docker', ['info', '--format', '{{.ServerVersion}}']);
-        const version = await effects.run('docker', ['compose', 'version', '--short']);
+        const nativeRoot = existing ? '/path/to/new-empty-directory' : record.root;
+        const quotedRoot = `'${String(nativeRoot).replaceAll("'", "'\\''")}'`;
+        const quotedName = `'${String(identityName ?? record.messengerIdentity ?? 'Your Name').replaceAll("'", "'\\''")}'`;
+        const recovery = [
+          'Please install Docker Desktop on macOS/Windows, or Docker Engine with the Compose plugin on Linux, and start Docker before retrying.',
+          'Docker is recommended for macOS and Windows.',
+          `Alternatively, use native installation: ours-install server install --mode packages --state-dir ${quotedRoot} --identity-name ${quotedName}`,
+          'Native mode requires systemd user services on Linux/WSL or a launchd GUI session on macOS.',
+          ...(existing ? ['Keep this existing Docker installation in Docker mode; use a separate empty directory for a new native installation.'] : []),
+        ].join('\n');
+        try {
+          await effects.run('docker', ['info', '--format', '{{.ServerVersion}}']);
+        } catch (cause) {
+          const problem = cause.code === 'ENOENT'
+            ? 'Docker command was not found in PATH.'
+            : `Docker Engine is not reachable. Start Docker and check that your user can access it.\nDetails: ${cause.message}`;
+          throw new Error(`${problem}\n${recovery}`, { cause });
+        }
+        let version;
+        try {
+          version = await effects.run('docker', ['compose', 'version', '--short']);
+        } catch (cause) {
+          throw new Error(`Docker Compose 2.35 or newer is required, but the Compose plugin could not run. Update Docker Desktop or install the Docker Compose plugin.\n${recovery}`, { cause });
+        }
         const match = /^v?(\d+)\.(\d+)/.exec(version.stdout.trim());
-        if (!match || Number(match[1]) < 2 || (Number(match[1]) === 2 && Number(match[2]) < 35)) throw new Error('Docker Compose 2.35 or newer is required');
+        if (!match || Number(match[1]) < 2 || (Number(match[1]) === 2 && Number(match[2]) < 35)) {
+          throw new Error(`Docker Compose 2.35 or newer is required. Update Docker Desktop or the Docker Compose plugin.\n${recovery}`);
+        }
         if (operation !== 'status') {
           // Compose clients can disappear while their Engine-owned command continues.
           const active = await effects.run('docker', ['ps', '--filter', `label=com.docker.compose.project=${record.project}`, '--filter', 'label=com.docker.compose.oneoff=True', '--format', '{{.ID}}']);
@@ -659,7 +708,7 @@ export function networkEffects(effects) {
         const { dependencies } = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
         writeFileSync(join(record.workDir, 'scripts/maintenance/package.json'), JSON.stringify({ private: true, type: 'module', dependencies }, null, 2) + '\n', { mode: 0o600 });
         const image = await effects.run('docker', ['image', 'inspect', `${record.project}:runtime`], { allowCodes: [1] });
-        if (image.code !== 0) await compose(record, ['build', 'daemon']);
+        if (image.code !== 0) await compose(record, ['build', 'daemon'], { stream: true, env: { BUILDKIT_PROGRESS: 'plain' } });
         if (runtimeOnly) return;
         await compose(record, ['run', '--rm', '--no-deps', '-T', 'prepare', 'prepare']);
       } else {
@@ -667,8 +716,8 @@ export function networkEffects(effects) {
           const sourceRoot = join(record.root, `build-${randomUUID()}`);
           ensurePrivateDirectory(sourceRoot);
           try {
-            await effects.run(process.execPath, [join(record.workDir, 'scripts/build/build.mjs')], { cwd: record.workDir, env: { OURS_BUILD_ROOT: record.workDir, OURS_SOURCE_ROOT: sourceRoot } });
-            await effects.run('npm', ['install', '--omit=dev', '--no-audit', '--no-fund'], { cwd: record.workDir });
+            await effects.run(process.execPath, [join(record.workDir, 'scripts/build/build.mjs')], { stream: true, cwd: record.workDir, env: { OURS_BUILD_ROOT: record.workDir, OURS_SOURCE_ROOT: sourceRoot } });
+            await effects.run('npm', ['install', '--omit=dev', '--no-audit', '--no-fund'], { stream: true, cwd: record.workDir });
             await effects.run(process.execPath, [join(record.workDir, 'scripts/build/record-build.mjs')], { cwd: record.workDir, env: { OURS_BUILD_ROOT: record.workDir } });
             writePrivateNew(join(record.workDir, '.packages-ready'), 'ready\n');
           } finally { rmSync(sourceRoot, { recursive: true, force: true }); }
@@ -1061,13 +1110,19 @@ export function networkEffects(effects) {
           if ((await effects.serverLifecycle(record, 'status', selected)).length) throw new Error('Writers did not stop');
           return;
         }
-        if (selected.includes('daemon')) await compose(record, ['up', '-d', '--no-build', '--no-deps', '--wait', 'daemon']);
+        const start = async service => {
+          effects.out(`Starting ${service}; waiting for readiness...`);
+          try { await compose(record, ['up', '-d', '--no-build', '--no-deps', '--wait', service]); }
+          catch (cause) { throw await dockerStartupError(record, service, cause); }
+          effects.out(`${service} is ready.`);
+        };
+        if (selected.includes('daemon')) await start('daemon');
         const failures = [];
         for (const service of selected.filter(s => s !== 'daemon')) {
-          try { await compose(record, ['up', '-d', '--no-build', '--no-deps', '--wait', service]); }
-          catch { failures.push(service); }
+          try { await start(service); }
+          catch (error) { failures.push({ service, error }); }
         }
-        if (failures.length) throw new Error(`Application readiness failed: ${failures.join(', ')}. Check owning prerequisites; no identities were created.`);
+        if (failures.length) throw new Error(`Application readiness failed: ${failures.map(f => f.service).join(', ')}. Check the selected application prerequisites.\n${failures.map(f => f.error.message).join('\n\n')}`);
         return;
       }
       return nativeLifecycle(record, operation, selected, { effects, localEnv, ownerCommand, bin });
@@ -1090,7 +1145,7 @@ export function networkEffects(effects) {
       // Full metadata and authenticated capability validation follows before publication.
       return validateHostProfile({ endpoint: url.origin, expectedInstanceId: selection.instanceId, credentialPath: resolve(credentialPath) });
     },
-    importClientProfile({ profile, sourcesPath, sources: resolvedSources, integrations, fleetSettingsPath }) {
+    importClientProfile({ profile, sourcesPath, sources: resolvedSources, integrations, fleetSettingsPath, refresh = false }) {
       const root = join(home, '.ours-client');
       const configPath = join(root, 'profile.json');
       const credentialPath = join(root, 'credential');
@@ -1101,13 +1156,13 @@ export function networkEffects(effects) {
       const credential = readFileSync(profile.credentialPath, 'utf8');
       if (!credential.trim()) throw new Error('Client credential is empty');
       // Read every supplied input before any publication. Existing setup settings win on retry.
-      const sources = current ? null : resolvedSources
+      const sources = current && !refresh ? null : resolvedSources
         ? Buffer.from(`${JSON.stringify(resolvedSources, null, 2)}\n`)
         : readFileSync(sourcesPath);
-      const fleetSettings = !current && fleetSettingsPath ? readFileSync(fleetSettingsPath) : null;
+      const fleetSettings = (!current || refresh) && fleetSettingsPath ? readFileSync(fleetSettingsPath) : null;
       if (fleetSettings) JSON.parse(fleetSettings.toString());
       ensurePrivateDirectory(root);
-      if (current) {
+      if (current && !refresh) {
         assertPrivateRegularFile(credentialPath, 'managed credential');
         if (readFileSync(credentialPath, 'utf8') !== credential) atomicWriteConfig(credentialPath, credential);
         return { configPath, profile: validateHostProfile(current), settings: current.installer };
@@ -1122,12 +1177,13 @@ export function networkEffects(effects) {
       atomicWriteConfig(configPath, JSON.stringify(saved, null, 2) + '\n');
       return { configPath, profile: validateHostProfile(saved), settings };
     },
-    async acquireClientPackages(configPath, sourcesPath, integrations) {
+    async acquireClientPackages(configPath, sourcesPath, integrations, { refresh = false } = {}) {
       const manifest = JSON.parse(readFileSync(sourcesPath, 'utf8'));
       // Public SDK client APIs are actual integration dependencies; Fleet also owns CLI usage.
       const selected = [...new Set(['sdk', ...(integrations.includes('fleet') ? ['cli'] : []), ...integrations])];
       const packages = selectSourcePackages(manifest, 'client', selected);
-      const root = join(home, '.ours-client-install', createHash('sha256').update(configPath).digest('hex').slice(0, 16));
+      const selectionKey = refresh ? JSON.stringify([configPath, manifest, integrations]) : configPath;
+      const root = join(home, '.ours-client-install', createHash('sha256').update(selectionKey).digest('hex').slice(0, 16));
       const hasGit = Object.values(packages).some(selection => selection.source);
       await effects.run('npm', ['--version']);
       if (hasGit) {
@@ -1147,12 +1203,12 @@ export function networkEffects(effects) {
           const sourceRoot = join(root, `build-${randomUUID()}`);
           ensurePrivateDirectory(sourceRoot);
           try {
-            await effects.run(process.execPath, [join(INSTALLER_ASSETS, 'scripts/build/build.mjs')], { cwd: root, env: { OURS_BUILD_ROOT: root, OURS_SOURCE_ROOT: sourceRoot, OURS_BUILD_PACKAGES: selected.join(',') } });
+            await effects.run(process.execPath, [join(INSTALLER_ASSETS, 'scripts/build/build.mjs')], { stream: true, cwd: root, env: { OURS_BUILD_ROOT: root, OURS_SOURCE_ROOT: sourceRoot, OURS_BUILD_PACKAGES: selected.join(',') } });
           } finally { rmSync(sourceRoot, { recursive: true, force: true }); }
         } else {
           writeFileSync(join(root, 'package.json'), JSON.stringify({ name: 'ours-native-clients', private: true, dependencies: Object.fromEntries(Object.entries(packages).map(([name, selection]) => [name, selection.version])) }), { mode: 0o600 });
         }
-        await effects.run('npm', ['install', '--omit=dev', '--no-audit', '--no-fund'], { cwd: root });
+        await effects.run('npm', ['install', '--omit=dev', '--no-audit', '--no-fund'], { stream: true, cwd: root });
         verifyReleaseGraph(root, manifest, { requiredPackages: Object.keys(packages) });
         writePrivateNew(join(root, '.packages-ready'), 'ready\n');
       }
@@ -1365,5 +1421,5 @@ async function nativeLifecycle(record, operation, selected, { effects, localEnv,
       failures.push(service);
     }
   }
-  if (failures.length) throw new Error(`Application readiness failed: ${failures.join(', ')}. Check owning prerequisites; no identities were created.`);
+  if (failures.length) throw new Error(`Application readiness failed: ${failures.join(', ')}. Check the selected application prerequisites.`);
 }

package/lib/fleet-settings.mjs

@@ -0,0 +1,43 @@
+// Structural preflight adapted from @ours.network/fleet src/init-wizard.ts
+// (readInitSettings/generateSetup), shipped in Fleet 1.2.0-nightly.1.
+// This checks complete answers before installer effects, without duplicating
+// Fleet's evolving model catalog. Fleet init remains authoritative for model
+// membership, exact capability arrays, and its packaged preset validation.
+const WORKS = ['development', 'review', 'coordination'];
+const EFFORTS = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+const REASONING = { quick: 'low', balanced: 'medium', thorough: 'high' };
+const fail = message => { throw new Error(`Fleet settings ${message}`); };
+function exactKeys(value, keys, label) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)
+    || Object.keys(value).sort().join('\0') !== [...keys].sort().join('\0'))
+    fail(`${label} must contain exactly ${keys.join(', ')}`);
+}
+function uniqueSelection(value, choices, label) {
+  if (!Array.isArray(value) || value.length === 0 || new Set(value).size !== value.length
+    || value.some(item => !choices.includes(item)))
+    fail(`${label} must be a nonempty unique selection of ${choices.join(', ')}`);
+}
+
+export function validateFleetSettings(value) {
+  exactKeys(value, ['subscriptions', 'assignmentStrategy', 'models', 'reasoning'], 'answers');
+  uniqueSelection(value.subscriptions, ['codex', 'claude'], 'subscriptions');
+  if (!['one-model', 'per-job'].includes(value.assignmentStrategy)) fail('assignmentStrategy must be one-model or per-job');
+  if (typeof value.reasoning !== 'string' || !Object.hasOwn(REASONING, value.reasoning)) fail('reasoning must be quick, balanced, or thorough');
+  exactKeys(value.models, WORKS, 'models');
+  const tuples = new Set();
+  for (const work of WORKS) {
+    const model = value.models[work];
+    exactKeys(model, ['harness', 'session', 'model', 'efforts'], `${work} model`);
+    if (!['codex', 'claude-code'].includes(model.harness)) fail(`${work} harness must be codex or claude-code`);
+    if (model.session !== 'acp') fail(`${work} session must be acp`);
+    if (typeof model.model !== 'string' || !model.model.trim()) fail(`${work} model must be a nonempty string`);
+    uniqueSelection(model.efforts, EFFORTS, `${work} efforts`);
+    if (!model.efforts.includes(REASONING[value.reasoning])) fail(`${work} efforts do not support the selected reasoning`);
+    if (!value.subscriptions.includes(model.harness === 'codex' ? 'codex' : 'claude'))
+      fail(`${work} uses a harness outside the selected subscriptions`);
+    tuples.add(JSON.stringify([model.harness, model.session, model.model]));
+  }
+  if (value.assignmentStrategy === 'one-model' && tuples.size !== 1)
+    fail('one-model assignment requires the same model for development, review, and coordination');
+  return value;
+}