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

package/lib/effects.mjs

@@ -13,17 +13,19 @@
 
 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';
 import { classifyStateDir } from './detect.mjs';
 import { BASE_RECORDS, CONTEXT, readBuildRecords, equalBuildRecords, initializeBuildMarker } from '../assets/scripts/maintenance/build-context.mjs';
+import { releaseBinding, verifyReleaseGraph, verifyRuntimeRelease } from '../assets/scripts/maintenance/release-graph.mjs';
 
 /** GET http://127.0.0.1:<port>/state-dir — the unauthenticated identity probe. */
 async function probePort(port, { timeoutMs = 1500 } = {}) {
@@ -332,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),
@@ -412,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}` : ''}`);
       }
@@ -532,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);
@@ -565,11 +590,20 @@ export function networkEffects(effects) {
     }
   };
   return {
+    ...createServerOnboarding(effects, { compose, localEnv, bin }),
     sourcePolicyHash(path) {
       return createHash('sha256').update(readFileSync(path)).digest('hex');
     },
     packagedSourcePolicy() {
-      return JSON.parse(readFileSync(PACKAGED_SOURCE_POLICY, 'utf8'));
+      const policy = JSON.parse(readFileSync(PACKAGED_SOURCE_POLICY, 'utf8'));
+      const release = releaseBinding(policy);
+      if (release) {
+        const embedded = JSON.parse(readFileSync(join(INSTALLER_ASSETS, 'release.json'), 'utf8'));
+        if (JSON.stringify(release) !== JSON.stringify(embedded)) throw new Error('Packaged source policy differs from immutable release');
+      } else if (Object.values(policy.packages ?? {}).some(p => p.type === 'npm')) {
+        throw new Error('Packaged npm source policy is missing its release binding');
+      }
+      return policy;
     },
     async resolveSourcePolicy(policy, role, clients = []) {
       return resolveSourcePolicy(policy, role, clients, async (name, range) => {
@@ -592,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');
@@ -600,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}}']);
@@ -650,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 {
@@ -658,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 }); }
@@ -867,6 +925,7 @@ export function networkEffects(effects) {
     },
     async recordRuntimeBuild(record) {
       if (record.mode === 'docker') return; // Image preparation records its build.
+      verifyRuntimeRelease(record.workDir);
       const tree = join(record.workDir, 'dependency-tree.json');
       if (!existsSync(tree)) {
         const result = await effects.run('npm', ['ls', '--omit=dev', '--all', '--json'], { cwd: record.workDir });
@@ -1051,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 });
@@ -1080,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');
@@ -1091,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 };
@@ -1112,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) {
@@ -1137,14 +1203,16 @@ 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');
       }
+      verifyReleaseGraph(root, manifest, { requiredPackages: Object.keys(packages) });
       // Local acquisition alone does not publish native commands. Use the user's
       // configured npm prefix and retained dependency closure, including on retry.
       for (const name of integrations.filter(name => name === 'fleet' || name === 'codex')) {
@@ -1154,22 +1222,34 @@ export function networkEffects(effects) {
       return { localPackages, packages: {}, fleetBin: integrations.includes('fleet') ? join(root, 'node_modules/.bin/ours-fleet') : null };
     },
     async prepareClientMarketplace(name, packagePath) {
-      const root = join(dirname(dirname(dirname(packagePath))), 'marketplaces', name);
+      const acquisitionRoot = dirname(dirname(dirname(packagePath)));
+      const sourcePath = join(acquisitionRoot, 'sources.json');
+      const policy = existsSync(sourcePath) ? JSON.parse(readFileSync(sourcePath, 'utf8')) : {}; // Retained pre-release client acquisitions.
+      const release = releaseBinding(policy);
+      const integrationsPath = join(acquisitionRoot, 'integrations.json');
+      const integrations = existsSync(integrationsPath) ? JSON.parse(readFileSync(integrationsPath, 'utf8')) : null;
+      const requiredPackages = integrations ? [...new Set(['sdk', ...(integrations.includes('fleet') ? ['cli'] : []), ...integrations])].map(name => '@ours.network/' + name) : Object.keys(policy.packages ?? {});
+      verifyReleaseGraph(acquisitionRoot, policy, { requiredPackages });
+      const root = join(acquisitionRoot, 'marketplaces', name);
       const plugin = join(root, 'plugins', 'ours');
       if (!existsSync(plugin)) {
         mkdirSync(dirname(plugin), { recursive: true, mode: 0o700 });
         cpSync(packagePath, plugin, { recursive: true });
         const manifestPath = join(plugin, 'package.json');
         const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
-        for (const dependency of ['sdk', 'cli']) {
+        for (const dependency of release ? [] : ['sdk', 'cli']) {
           const name = `@ours.network/${dependency}`;
           if (manifest.dependencies?.[name]) manifest.dependencies[name] = `file:${join(dirname(packagePath), dependency)}`;
         }
         writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
       }
+      if (release && JSON.stringify(JSON.parse(readFileSync(join(plugin, 'package.json'), 'utf8'))) !== JSON.stringify(JSON.parse(readFileSync(join(packagePath, 'package.json'), 'utf8')))) {
+        throw new Error('Marketplace package differs from verified release acquisition');
+      }
       // Native caches copy plugin contents; local SDK/CLI dependencies must not
       // remain links to acquisition paths. Repeating setup also repairs an interrupted install.
       await effects.run('npm', ['install', '--install-links', '--omit=dev', '--ignore-scripts', '--no-audit', '--no-fund'], { cwd: plugin });
+      verifyReleaseGraph(plugin, policy);
       const value = name === 'codex'
         ? { name: 'ours-codex-marketplace', plugins: [{ name: 'ours', source: { source: 'local', path: './plugins/ours' }, policy: { installation: 'AVAILABLE', authentication: 'ON_INSTALL' }, category: 'Productivity' }] }
         : { name: 'ours.network', owner: { name: 'Adapt Toolkit' }, plugins: [{ name: 'ours', source: './plugins/ours' }] };
@@ -1341,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;
+}

package/lib/orchestrate.mjs

@@ -1266,6 +1266,7 @@ async function executeServerCommand(args, effects) {
   } else {
     if (args.operation !== 'install' || !args.mode) throw new Error('First server install requires --mode');
     record = effects.newInstallation(args.stateDir, args.mode);
+    for (const key of ['port', 'coworkPort', 'messengerPort']) if (args[key] !== undefined) record[key] = args[key];
   }
   if (record.layoutConversion && !['install', 'start', 'stop', 'status'].includes(args.operation)) {
     throw new Error('Layout conversion is incomplete; resume with server install or server start before changing state or authority');
@@ -1273,14 +1274,32 @@ async function executeServerCommand(args, effects) {
   if (record.buildTransition && !['stop', 'status', record.buildTransition.operation].includes(args.operation)) {
     throw new Error(`Server build activation is incomplete; repeat server ${record.buildTransition.operation} before other mutations`);
   }
+  const showInstallProgress = args.operation === 'install' && !(existing && (record.schema === 1 || record.layoutConversion));
+  const installStageCount = (existing ? 7 : 9) + (args.identityName ? 2 : 0);
+  let completedInstallStages = 0;
+  const installStage = async (label, explanation, action) => {
+    if (!showInstallProgress) return action();
+    effects.out(progress(completedInstallStages, installStageCount, label, explanation));
+    try {
+      const result = await action();
+      completedInstallStages += 1;
+      effects.out(ok(`${label} complete`));
+      return result;
+    } catch (error) {
+      effects.out(warn(`Server installation stopped during ${label.toLowerCase()}.`));
+      throw error;
+    }
+  };
   if ((!existing || args.operation === 'update') && !record.buildTransition) {
-    const policy = args.sources ? effects.readJson(args.sources) : effects.packagedSourcePolicy();
-    args.resolvedSources = await effects.resolveSourcePolicy(policy, 'server');
+    args.resolvedSources = await installStage('Package selection', 'Resolve the selected server packages before installation.', async () => {
+      const policy = args.sourcePolicy ?? (args.sources ? effects.readJson(args.sources) : effects.packagedSourcePolicy());
+      return effects.resolveSourcePolicy(policy, 'server');
+    });
   }
   if (!existing && args.sources) record.sourcePolicyHash = effects.sourcePolicyHash(args.sources);
-  await effects.serverPreflight(record, args.operation, {
-    existing, sourcePath: args.sources ?? record.sourcesPath, sourceManifest: args.resolvedSources,
-  });
+  await installStage('Prerequisite checks', record.mode === 'docker' ? 'Check Docker Engine and Docker Compose.' : 'Check native tools and the user service manager.', () => effects.serverPreflight(record, args.operation, {
+    existing, sourcePath: args.sources ?? record.sourcesPath, sourceManifest: args.resolvedSources, identityName: args.identityName,
+  }));
   if (existing && (record.schema === 1 || record.layoutConversion)
     && ['install', 'start', 'restart', 'update', 'rebuild'].includes(args.operation)) {
     record = record.mode === 'docker'
@@ -1295,16 +1314,27 @@ async function executeServerCommand(args, effects) {
     await effects.stopPendingConversion(record);
   } else if (args.operation === 'install') {
     if (!existing) {
-      await effects.initializeSelection(record, args.resolvedSources);
-      effects.writeJson(recordPath, JSON.stringify(record, null, 2) + '\n');
+      await installStage('Installation setup', 'Save the selected packages and installation settings.', async () => {
+        await effects.initializeSelection(record, args.resolvedSources);
+        effects.writeJson(recordPath, JSON.stringify(record, null, 2) + '\n');
+      });
     }
-    await effects.prepareInstallation(record);
+    await installStage('Runtime preparation', record.mode === 'docker' ? 'Prepare the Docker runtime. Downloads and builds may take several minutes.' : 'Download and prepare the native runtime packages. This may take several minutes.', () => effects.prepareInstallation(record));
     // A repeated setup repairs delivery with the retained master and exact packages.
-    await effects.serverLifecycle(record, 'stop');
-    await effects.serverAccess(record, 'access-init', { migrate: !!args.migrate });
-    await effects.serverAccess(record, 'access-issue');
-    await effects.recordInstallationBuild(record);
-    await effects.serverLifecycle(record, 'start');
+    await installStage('Service shutdown', 'Stop managed services before configuring access.', () => effects.serverLifecycle(record, 'stop'));
+    await installStage('Credential initialization', 'Initialize or retain the installation credentials.', () => effects.serverAccess(record, 'access-init', { migrate: !!args.migrate }));
+    await installStage('Credential delivery', 'Prepare access for the selected services.', () => effects.serverAccess(record, 'access-issue'));
+    await installStage('Build verification', 'Record the installed runtime and selected package versions.', () => effects.recordInstallationBuild(record));
+    if (args.identityName) {
+      await installStage('Daemon startup', 'Start the daemon and restore its retained identities.', () => effects.serverLifecycle(record, 'start', ['daemon']));
+      const identity = await installStage('Human identity', 'Keep the existing Human identity, or create it on a fresh daemon.', () => effects.serverEnsureIdentity(record, args.identityName));
+      record.messengerIdentity = identity.name;
+      effects.writeJson(recordPath, JSON.stringify(record, null, 2) + '\n');
+      await installStage('Application startup', 'Start the selected applications and check readiness.', () => effects.serverLifecycle(record, 'start', record.services.filter(name => name !== 'daemon')));
+    } else {
+      await installStage('Service startup', 'Start the daemon and selected services, then check readiness.', () => effects.serverLifecycle(record, 'start'));
+    }
+    if (showInstallProgress) effects.out(progress(installStageCount, installStageCount, 'Installation complete', 'The selected services are ready.'));
   } else if (['backup', 'restore', 'reset'].includes(args.operation)) {
     await effects.serverMaintenance(record, args);
   } else if (['update', 'rebuild'].includes(args.operation)) {
@@ -1341,18 +1371,18 @@ async function executeServerCommand(args, effects) {
   return EXIT_OK;
 }
 
-async function runClientCommand(command, effects) {
+export async function runClientCommand(command, effects) {
   const managedPath = join(effects.home, '.ours-client', 'profile.json');
   const saved = effects.readManagedClientProfile();
   let configPath = command.config;
   if (!configPath && saved) {
-    if (effects.interactive && !await effects.ask(`Reuse saved client server ${saved.endpoint}?`, true))
+    if (!command.preset && effects.interactive && !await effects.ask(`Reuse saved client server ${saved.endpoint}?`, true))
       throw new InstallUsageError('Saved client default retained; use an explicit prepared profile to validate replacement input');
     configPath = managedPath;
   }
   let profile;
   if (configPath) profile = validateHostProfile(effects.readProfile(configPath));
-  else if (effects.interactive) {
+  else if (!command.preset && effects.interactive) {
     const endpoint = await effects.askLine('Server HTTP endpoint: ', 'http://127.0.0.1:3050');
     const credentialPath = await effects.askLine('Private issued-token file: ', '');
     if (!credentialPath) throw new InstallUsageError('Client setup requires an issued-token file');
@@ -1369,40 +1399,51 @@ async function runClientCommand(command, effects) {
   await effects.verifyPackagedMcp(configPath || profile);
   const settings = saved?.installer ?? (configPath ? effects.readJson(configPath)?.installer : undefined);
   const settingsBase = saved ? dirname(managedPath) : configPath ? dirname(configPath) : process.cwd();
-  let integrations = settings?.integrations;
-  if (!integrations && effects.interactive) {
+  let integrations = command.integrations ?? settings?.integrations;
+  if (!integrations && !command.preset && effects.interactive) {
     integrations = [];
     for (const name of ['codex', 'claude-code', 'fleet']) if (await effects.ask(`Install ${name}?`, name !== 'fleet')) integrations.push(name);
   }
   if (!Array.isArray(integrations) || !integrations.length || integrations.some(name => !['codex', 'claude-code', 'fleet'].includes(name)) || new Set(integrations).size !== integrations.length) throw new InstallUsageError('installer.integrations must select codex, claude-code and/or fleet');
-  let fleetSettingsPath = settings?.fleetSettingsPath;
+  let fleetSettingsPath = command.preset ? command.fleetSettingsPath : settings?.fleetSettingsPath;
+  if (command.nonInteractive && integrations.includes('fleet') && !fleetSettingsPath) throw new InstallUsageError('Fleet in CLI mode requires --fleet-settings; no interactive wizard will be opened');
   if (fleetSettingsPath !== undefined && (typeof fleetSettingsPath !== 'string' || !fleetSettingsPath))
     throw new InstallUsageError('installer.fleetSettingsPath must be a non-empty path when supplied');
   if (fleetSettingsPath) fleetSettingsPath = resolve(settingsBase, fleetSettingsPath);
   const selectedClients = [...new Set(['sdk', ...(integrations.includes('fleet') ? ['cli'] : []), ...integrations])];
   let sourcesPath = settings?.sourcesPath;
   let resolvedSources;
-  if (saved) sourcesPath = resolve(settingsBase, sourcesPath);
+  if (command.sourcePolicy) {
+    resolvedSources = await effects.resolveSourcePolicy(command.sourcePolicy, 'client', selectedClients);
+    sourcesPath = undefined;
+  } else if (saved) sourcesPath = resolve(settingsBase, sourcesPath);
   else {
     if (sourcesPath) sourcesPath = resolve(settingsBase, sourcesPath);
     const policy = sourcesPath ? effects.readJson(sourcesPath) : effects.packagedSourcePolicy();
     resolvedSources = await effects.resolveSourcePolicy(policy, 'client', selectedClients);
   }
-  const imported = effects.importClientProfile({ profile, sourcesPath, sources: resolvedSources, integrations, fleetSettingsPath });
+  effects.out(progress(0, 4, 'Client configuration', 'Prepare the selected integrations and private connection profile.'));
+  const imported = effects.importClientProfile({ profile, sourcesPath, sources: resolvedSources, integrations, fleetSettingsPath, refresh: !!command.preset });
   try {
     await effects.verifyHostProfile(imported.configPath);
-    const exactSuite = await effects.acquireClientPackages(imported.configPath, imported.settings.sourcesPath, integrations);
+    effects.out(progress(1, 4, 'Client packages', 'Acquire and verify the selected client package versions.'));
+    const exactSuite = await effects.acquireClientPackages(imported.configPath, imported.settings.sourcesPath, integrations, { refresh: !!command.preset });
     const args = { assumeYes: true, dryRun: false, channel: 'latest', clientIntegrations: integrations,
       acquiredFleet: exactSuite.fleetBin, fleetSettingsPath: imported.settings.fleetSettingsPath };
     const target = { mode: 'host-profile', managed: true, configPath: imported.configPath, profile: imported.profile, endpoint: imported.profile.endpoint };
+    effects.out(progress(2, 4, 'Client integrations', 'Register the selected agent integrations.'));
     const summary = await runHarnessPhase(args, effects, { target, isDefaultStateDir: false, exactSuite });
-    if (integrations.includes('fleet')) summary.push(await runFleetPhase(args, effects, { target, isDefaultStateDir: false }));
+    if (integrations.includes('fleet')) {
+      effects.out(progress(3, 4, 'Fleet configuration', 'Apply prepared settings or open the selected Fleet wizard.'));
+      summary.push(await runFleetPhase(args, effects, { target, isDefaultStateDir: false }));
+    }
     const incomplete = integrations.filter(name => !summary.some(row => row.key === name && row.state === 'installed'));
     if (effects.env.OURS_CONFIG && resolve(effects.env.OURS_CONFIG) !== imported.configPath)
       effects.out(warn('This shell has an explicit OURS_CONFIG override. Unset it for new clients to use the saved default; installer did not edit your shell.'));
     effects.out(incomplete.length
       ? warn(`Client setup incomplete (${incomplete.join(', ')}); saved profile and settings retained. Re-run ours-install client install.`)
       : ok(`Client setup complete. New clients discover ${imported.configPath}; no OURS_CONFIG export is required.`));
+    if (!incomplete.length) effects.out(progress(4, 4, 'Client setup complete', 'All selected integrations are configured.'));
     return incomplete.length ? EXIT_REFUSED : EXIT_OK;
   } catch (error) {
     effects.out(warn(`Client setup incomplete: ${reason(error)}. Saved profile and settings retained; re-run ours-install client install.`));

package/lib/plan.mjs

@@ -6,6 +6,7 @@
 
 import { join, resolve, basename, dirname } from 'node:path';
 import { valid, validRange, satisfies } from 'semver';
+import { releaseBinding } from '../assets/scripts/maintenance/release-graph.mjs';
 
 export const CLI_UNIT_MARKER = '# Managed by @ours.network/cli';
 export const SYSTEMD_USER_DIR = ['.config', 'systemd', 'user'];
@@ -310,6 +311,7 @@ export function selectSourcePackages(manifest, role, clients = []) {
 
 /** Resolve a packaged compatibility policy into a role-filtered exact selection. */
 export async function resolveSourcePolicy(manifest, role, clients = [], resolveNpm) {
+  const release = releaseBinding(manifest);
   const names = role === 'server' ? SERVER_PACKAGES : clients.map(name => `@ours.network/${name}`);
   const packages = {};
   const sourceNames = new Set();
@@ -332,7 +334,7 @@ export async function resolveSourcePolicy(manifest, role, clients = [], resolveN
     } else throw new Error(`Missing source policy for ${name}`);
   }
   const sources = Object.fromEntries([...sourceNames].map(name => [name, manifest.sources[name]]));
-  const exact = { ...(sourceNames.size ? { sources } : {}), packages };
+  const exact = { ...(sourceNames.size ? { sources } : {}), packages, ...(release ? { release } : {}) };
   selectSourcePackages(exact, role, clients);
   return exact;
 }