@ours.network/fleet 1.2.0-nightly.70 → 1.2.0-nightly.72

package/dist/web/server.js

@@ -1,3 +1,7 @@
+import { FleetResourceViews, ResourceBindingError, canonicalResourceDescriptor } from './resource-views.js';
+import { publishFleetResourceCommit } from '../application/resource-observer.js';
+import { stateRoot, defaultConfigPath } from '../paths.js';
+import { conversationPreview } from '../application/conversation-history.js';
 import { registerConversationStream } from './conversation-stream.js';
 import { conversationHasAttachment } from '../application/conversation-history.js';
 import { readDeliveredFile } from '../file-delivery/store.js';
@@ -49,7 +53,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         reply.header('Content-Security-Policy', "default-src 'none'; base-uri 'none'; form-action 'none'; frame-ancestors 'none'");
         if (request.url.startsWith('/api/'))
             reply.header('Cache-Control', 'no-store');
-        if (request.headers.origin === auth.appOrigin && request.url.startsWith('/api/')) {
+        if (auth.appOrigin && request.headers.origin === auth.appOrigin && request.url.startsWith('/api/')) {
             reply.header('Access-Control-Allow-Origin', auth.appOrigin).header('Vary', 'Origin');
             reply.header('Access-Control-Allow-Methods', 'GET,POST,PUT,PATCH,DELETE,OPTIONS');
             reply.header('Access-Control-Expose-Headers', 'X-Ours-Workspace-Auth, X-Ours-Request-Id');
@@ -61,6 +65,12 @@ export async function buildWebServer(services, boundary, options = {}) {
         }
         auth.validateBoundary(request, false);
     });
+    app.addHook('onResponse', async (request, reply) => {
+        if (reply.statusCode < 400 && ['POST', 'PUT', 'PATCH', 'DELETE'].includes(request.method) && !request.url.includes('/resource-subscriptions')) {
+            publishFleetResourceCommit(services.configuration?.path ?? defaultConfigPath());
+            publishFleetResourceCommit(stateRoot());
+        }
+    });
     app.post('/api/v1/layout-bindings/:id/control', async (request) => {
         // Initial support is direct same-host Fleet-to-Fleet transport.
         const forwarded = Object.keys(request.headers).some(name => name === 'forwarded' || name.startsWith('x-forwarded-') || name === 'x-real-ip' || name === 'via');
@@ -74,6 +84,8 @@ export async function buildWebServer(services, boundary, options = {}) {
         return services.layoutBindings.control(request.params.id, request.headers.authorization, request.body);
     });
     app.setErrorHandler(async (error, request, reply) => {
+        if (error instanceof ResourceBindingError)
+            return reply.code(error.status).send({ error: { code: 'resource_binding', message: error.message } });
         const privateToolParseError = ['/api/v1/roles/:id/ours/call', '/api/v1/layout-bindings/:id/control'].includes(request.routeOptions.url ?? '')
             && error instanceof Error && 'code' in error
             && typeof error.code === 'string' && error.code.startsWith('FST_ERR_CTP_');
@@ -183,8 +195,10 @@ export async function buildWebServer(services, boundary, options = {}) {
             auditDegraded: audit.degraded,
         };
     });
+    let onboardingObserved;
     app.get('/api/v1/onboarding', async (request) => {
-        auth.authenticate(request);
+        const browser = auth.authenticate(request);
+        const revision = services.configuration?.read().revision;
         // Opening an existing workspace needs configuration state, not CLI/account discovery.
         // Keep the full report for the setup screens and older App clients.
         if (request.query.view === 'state')
@@ -202,7 +216,12 @@ export async function buildWebServer(services, boundary, options = {}) {
         // When it could not be asked, none is offered and the reason is reported.
         const codexModels = services.codexModels ? await services.codexModels() : undefined;
         const offered = (model) => model.harness !== 'codex' || !codexModels || (codexModels.state === 'known' && codexModels.models.includes(model.model));
-        return { harnesses, catalog: catalog.models.filter(offered), ...(codexModels ? { codexModels: codexModels.state === 'known' ? { state: 'known' } : codexModels } : {}), providers: services.subscriptions ? await services.subscriptions.list() : [], coordinator: 'FleetCoordinator', configured: onboardingConfigured() };
+        const payload = { harnesses, catalog: catalog.models.filter(offered), ...(codexModels ? { codexModels: codexModels.state === 'known' ? { state: 'known' } : codexModels } : {}), providers: services.subscriptions ? await services.subscriptions.list() : [], coordinator: 'FleetCoordinator', configured: onboardingConfigured() };
+        if (revision === services.configuration?.read().revision) {
+            onboardingObserved = { owner: browser.id, revision, payload };
+            events.publish('onboarding.changed', {});
+        }
+        return payload;
     });
     // First-time setup is what creates the persistent coordinator. A configuration that loads and
     // has it is set up, whatever its brains are called; its models are then changed by editing it.
@@ -283,6 +302,9 @@ export async function buildWebServer(services, boundary, options = {}) {
     app.get('/api/v1/roles', async (request) => {
         auth.authenticate(request);
         const query = request.query;
+        // Unbound REST retains the existing problem-bearing inventory. Bound reads
+        // are handled by the strict resource preHandler before this route.
+        services.invalidateResourceCaches?.();
         return { roles: await services.query.list(query.includeTemporary === 'true') };
     });
     const taskApi = async (fn) => {
@@ -309,9 +331,152 @@ export async function buildWebServer(services, boundary, options = {}) {
             throw new FleetError('capability_unavailable', 'task operations are unavailable');
         return services.taskRooms;
     };
+    const projectTasks = async (query, strict = true) => {
+        const states = ['backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'];
+        if (query.state && query.state !== 'all' && !states.includes(query.state))
+            throw new FleetError('invalid_request', 'invalid task state filter');
+        if (query.groupByList !== undefined && !['true', 'false'].includes(query.groupByList))
+            throw new FleetError('invalid_request', 'groupByList must be true or false');
+        if (query.includeDeleting !== undefined && !['true', 'false'].includes(query.includeDeleting))
+            throw new FleetError('invalid_request', 'includeDeleting must be true or false');
+        const state = query.state && query.state !== 'all' ? query.state : undefined;
+        const filter = { strict, ...(state ? { state } : {}), ...(query.list ? { list: query.list } : {}),
+            ...(query.includeDeleting === 'true' ? { includeDeleting: true } : {}) };
+        const api = requireTaskRooms();
+        return taskApi(() => query.groupByList === 'true'
+            ? { groups: api.groupedTasks(filter).map(group => ({ ...group, tasks: group.tasks.map(task => api.withLayoutRooms(task)) })) }
+            : { tasks: api.listTasks(filter).map(task => api.withLayoutRooms(task)) });
+    };
+    const project = async (descriptor, signal, owner = '') => {
+        signal.throwIfAborted();
+        services.invalidateResourceCaches?.();
+        switch (descriptor.resource) {
+            case 'task-layout':
+                try {
+                    return { layout: await taskApi(() => requireTaskRooms().taskLayout(descriptor.entityId)) };
+                }
+                catch (error) {
+                    if (error?.code === 'task_not_found' || error?.code === 'resource_not_found')
+                        return { deleted: true, id: descriptor.entityId };
+                    throw error;
+                }
+            case 'creation-action': return services.creation.get(descriptor.entityId) ?? { deleted: true, id: descriptor.entityId };
+            case 'action': return services.commands.get(descriptor.entityId) ?? { deleted: true, id: descriptor.entityId };
+            case 'member-addition':
+                try {
+                    return await taskApi(() => requireTaskRooms().memberAddition(descriptor.entityId, descriptor.receiptId));
+                }
+                catch (error) {
+                    if (['task_not_found', 'resource_not_found'].includes(error?.code) || error?.message === 'Member request not found')
+                        return { deleted: true, id: descriptor.receiptId };
+                    throw error;
+                }
+            case 'login':
+                // A foreign login must never be delivered, including its URL/device code.
+                try {
+                    return subscriptions().login(descriptor.entityId, owner).view();
+                }
+                catch (error) {
+                    if (error?.code === 'resource_not_found')
+                        return { deleted: true, id: descriptor.entityId };
+                    throw error;
+                }
+            case 'subscriptions': return { providers: await subscriptions().list(true) };
+            case 'onboarding-health': {
+                const revision = services.configuration?.read().revision;
+                if (onboardingObserved && onboardingObserved.revision !== revision)
+                    onboardingObserved = undefined;
+                const observed = onboardingObserved?.owner === owner ? onboardingObserved : undefined;
+                return { ...observed?.payload, observationCurrent: !!observed, configured: onboardingConfigured(), providers: services.subscriptions ? await services.subscriptions.list(true) : [] };
+            }
+            case 'roles': return { roles: await services.query.list(descriptor.includeTemporary ?? false, true) };
+            case 'tasks': return projectTasks({ state: descriptor.state, list: descriptor.list, groupByList: String(descriptor.groupByList ?? false), includeDeleting: String(descriptor.includeDeleting ?? false) });
+            case 'task-lists': return { lists: requireTaskRooms().listTaskLists() };
+            case 'configuration':
+                if (!services.configuration)
+                    throw new FleetError('capability_unavailable', 'fleet configuration editing is unavailable');
+                return { ...services.configuration.read(descriptor.includeDefinitions ?? false), provenance: services.presetProvenance?.read() ?? null };
+            case 'directory': {
+                const [roles, tasks] = await Promise.all([services.query.list(true, true), projectTasks({})]);
+                return { roles, tasks: tasks.tasks, lists: requireTaskRooms().listTaskLists() };
+            }
+            case 'previews': {
+                const roles = await services.repository.list(true), selected = new Map(roles.map(role => [role.id, role]));
+                const previews = {};
+                for (const id of descriptor.ids ?? []) {
+                    signal.throwIfAborted();
+                    const role = selected.get(id), dir = role && services.repository.stateDir(role);
+                    if (!role)
+                        continue;
+                    try {
+                        previews[id] = dir ? await conversationPreview(dir, signal) : { text: 'No recent agent output', at: '' };
+                    }
+                    catch {
+                        signal.throwIfAborted();
+                        // A damaged/unreadable ledger is unavailable, not empty or removed.
+                        // Keep this selected row observable so a repair can refresh it,
+                        // without retiring previews for the other selected roles.
+                        previews[id] = { text: 'Preview unavailable', at: '', unavailable: true };
+                    }
+                }
+                return { previews };
+            }
+        }
+    };
+    const resources = new FleetResourceViews(services.resourceScope ?? {}, project);
+    app.addHook('preClose', async () => resources.close());
+    app.get('/api/v1/resource-events', async (request, reply) => {
+        const browser = auth.authenticate(request);
+        reply.hijack();
+        reply.raw.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache, no-transform', Connection: 'keep-alive', 'X-Accel-Buffering': 'no' });
+        reply.raw.flushHeaders();
+        const opened = resources.open(reply.raw, browser.id, () => auth.sessionValid(browser));
+        const binding = auth.bindTransport(browser, opened.close);
+        reply.raw.once('close', () => binding());
+    });
+    app.post('/api/v1/resource-subscriptions', async (request, reply) => {
+        const browser = auth.authenticate(request, true), body = request.body;
+        const binding = resources.register(browser.id, String(body?.connectionId ?? ''), String(body?.viewId ?? ''), body?.subscriptionEpoch, body?.descriptor);
+        const retire = () => {
+            if (reply.raw.writableFinished)
+                return;
+            try {
+                resources.remove(browser.id, String(body.connectionId), String(body.viewId), body.subscriptionEpoch);
+            }
+            catch { /* Connection may already be closed. */ }
+        };
+        reply.raw.once('close', retire);
+        reply.raw.once('finish', () => reply.raw.off('close', retire));
+        if (reply.raw.destroyed)
+            retire();
+        return binding;
+    });
+    app.delete('/api/v1/resource-subscriptions', async (request) => {
+        const browser = auth.authenticate(request, true), body = request.body;
+        resources.remove(browser.id, String(body?.connectionId ?? ''), String(body?.viewId ?? ''), body?.subscriptionEpoch);
+        return { removed: true };
+    });
+    // Bound reads return precisely the registered initial capture, never an unrelated GET.
+    app.addHook('preHandler', async (request, reply) => {
+        if (request.method !== 'GET' || !request.headers['x-resource-connection'])
+            return;
+        const browser = auth.authenticate(request), headers = request.headers;
+        const baseline = await resources.bound(browser.id, String(headers['x-resource-connection']), String(headers['x-resource-view']), Number(headers['x-resource-epoch']), String(headers['x-resource-baseline']));
+        const expected = '/api/v1/' + baseline.descriptor.resource;
+        if (request.url.split('?')[0] !== expected)
+            throw new ResourceBindingError(409, 'resource route mismatch');
+        for (const name of ['Connection', 'View', 'Epoch', 'Baseline'])
+            reply.header('X-Resource-' + name, String(headers['x-resource-' + name.toLowerCase()]));
+        reply.header('X-Resource-Producer', baseline.producerGeneration).header('X-Resource-Revision', baseline.revision).header('X-Resource-Source-Generation', baseline.source.producerGeneration).header('X-Resource-Source-Position', baseline.source.position);
+        return reply.send(baseline.payload);
+    });
+    for (const resource of ['task-layout', 'creation-action', 'action', 'member-addition', 'login', 'onboarding-health'])
+        app.get('/api/v1/' + resource, async () => { throw new ResourceBindingError(409, 'resource binding required'); });
+    app.get('/api/v1/directory', async (request) => { auth.authenticate(request); return project({ viewId: 'read', resource: 'directory' }, new AbortController().signal); });
+    app.get('/api/v1/previews', async (request) => { auth.authenticate(request); const ids = String(request.query.ids ?? '').split(',').filter(Boolean); return project(canonicalResourceDescriptor({ viewId: 'read', resource: 'previews', ids }), new AbortController().signal); });
     app.get('/api/v1/task-lists', async (request) => {
         auth.authenticate(request);
-        return { lists: requireTaskRooms().listTaskLists() };
+        return project({ viewId: 'read', resource: 'task-lists' }, new AbortController().signal);
     });
     app.post('/api/v1/task-lists', async (request, reply) => {
         auth.authenticate(request, true);
@@ -334,21 +499,7 @@ export async function buildWebServer(services, boundary, options = {}) {
     });
     app.get('/api/v1/tasks', async (request) => {
         auth.authenticate(request);
-        const query = request.query;
-        const states = ['backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'];
-        if (query.state && query.state !== 'all' && !states.includes(query.state))
-            throw new FleetError('invalid_request', 'invalid task state filter');
-        if (query.groupByList !== undefined && !['true', 'false'].includes(query.groupByList))
-            throw new FleetError('invalid_request', 'groupByList must be true or false');
-        if (query.includeDeleting !== undefined && !['true', 'false'].includes(query.includeDeleting))
-            throw new FleetError('invalid_request', 'includeDeleting must be true or false');
-        const state = query.state && query.state !== 'all' ? query.state : undefined;
-        const filter = { ...(state ? { state } : {}), ...(query.list ? { list: query.list } : {}),
-            ...(query.includeDeleting === 'true' ? { includeDeleting: true } : {}) };
-        const api = requireTaskRooms();
-        return taskApi(() => query.groupByList === 'true'
-            ? { groups: api.groupedTasks(filter).map(group => ({ ...group, tasks: group.tasks.map(task => api.withLayoutRooms(task)) })) }
-            : { tasks: api.listTasks(filter).map(task => api.withLayoutRooms(task)) });
+        return projectTasks(request.query, false);
     });
     app.delete('/api/v1/tasks/:id', async (request, reply) => {
         auth.authenticate(request, true);
@@ -558,7 +709,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         auth.authenticate(request);
         if (!services.configuration)
             throw new FleetError('capability_unavailable', 'fleet configuration editing is unavailable');
-        return services.configuration.read(request.query.includeDefinitions === 'true');
+        return project({ viewId: 'read', resource: 'configuration', includeDefinitions: request.query.includeDefinitions === 'true' }, new AbortController().signal);
     });
     app.post('/api/v1/configuration/preview', async (request) => {
         auth.authenticate(request, true);

package/dist/workspace-enrollment.js

@@ -1,9 +1,9 @@
-import { validateAccountOrigin } from './account-origin.js';
+import { validateAccountOrigin, validateConfiguredAccountOrigin, validateConfiguredWorkspaceHost } from './account-origin.js';
 import { lstatSync, readFileSync, readdirSync, mkdirSync, existsSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { readClientProfile } from './client-profile.js';
-import { stateRoot, defaultConfigPath, workspaceOwnerInvite } from './paths.js';
-import { replaceFileAtomically } from './atomic-file.js';
+import { stateRoot, defaultConfigPath, workspaceOwnerInvite, workspaceBindingLock, workspaceReplacementFile } from './paths.js';
+import { replaceFileAtomically, withSynchronousFileLock } from './atomic-file.js';
 import { loadConfig, splitRootFor } from './config.js';
 import { parse, parseDocument, stringify } from 'yaml';
 import { randomUUID } from 'node:crypto';
@@ -25,7 +25,13 @@ export function decodeWorkspacePayload(input, options = {}) {
     catch {
         throw Error('Invalid workspace payload');
     }
-    if (!p || typeof p !== 'object' || Array.isArray(p) || p.version !== 1 || !['https://app.ours.network', 'https://app.ours-tunnel.com'].includes(p.appOrigin) || !/^[a-z0-9][a-z0-9-]{2,60}\.ours-tunnel\.com$/.test(p.hostname) || !/^[a-z0-9-]{2,30}@[a-z0-9-]{2,30}$/.test(p.rootName) || !/^[a-f0-9]{64}$/i.test(p.serverCid) || !p.challenge || !['nonce', 'accountId', 'workspaceId'].every(k => /^[\w-]{43}$/.test(String(p.challenge[k]))) || (!options.allowExpired && p.challenge.expiresAt <= Date.now()) || !Number.isSafeInteger(p.challenge.expiresAt) || p.challenge.expiresAt > Date.now() + 16 * 60000)
+    try {
+        validateConfiguredAccountOrigin(p?.appOrigin);
+    }
+    catch {
+        throw Error('Workspace payload is invalid or expired');
+    }
+    if (!p || typeof p !== 'object' || Array.isArray(p) || p.version !== 1 || !validateConfiguredWorkspaceHost(p.hostname) || !/^[a-z0-9-]{2,30}@[a-z0-9-]{2,30}$/.test(p.rootName) || !/^[a-f0-9]{64}$/i.test(p.serverCid) || !p.challenge || !['nonce', 'accountId', 'workspaceId'].every(k => /^[\w-]{43}$/.test(String(p.challenge[k]))) || (!options.allowExpired && p.challenge.expiresAt <= Date.now()) || !Number.isSafeInteger(p.challenge.expiresAt) || p.challenge.expiresAt > Date.now() + 16 * 60000)
         throw Error('Workspace payload is invalid or expired');
     for (const k of ['connectorToken', 'invitation']) {
         if (k === 'connectorToken' && p[k] === undefined)
@@ -58,7 +64,7 @@ export function checkWorkspaceConnector(payload) {
     catch {
         reject();
     }
-    if (previous.workspaceId !== payload.challenge.workspaceId || validateAccountOrigin(previous.appOrigin ?? 'https://app.ours.network') !== payload.appOrigin || (previous.serverCid && previous.serverCid.toUpperCase() !== payload.serverCid.toUpperCase()))
+    if (previous.workspaceId !== payload.challenge.workspaceId || validateAccountOrigin(previous.appOrigin) !== payload.appOrigin || (previous.serverCid && previous.serverCid.toUpperCase() !== payload.serverCid.toUpperCase()))
         reject();
     try {
         const file = join(dir, 'connector'), stat = lstatSync(file);
@@ -264,11 +270,24 @@ export async function enrollWorkspace(payload, configuration = defaultConfigPath
     const appOrigin = validateAccountOrigin(payload.appOrigin);
     const previousFile = join(dir, 'binding.json');
     let migrating = false;
-    if (existsSync(previousFile)) {
-        const previous = JSON.parse(readFileSync(previousFile, 'utf8'));
+    // Every decision below rests on this binding and on the unfinished replacement record (none, or the
+    // one this setup completes); both are rechecked under the binding lock before the first change and
+    // again at the final write, so a concurrent setup or replacement is never overwritten.
+    const read = (file) => existsSync(file) ? readFileSync(file, 'utf8') : null;
+    const priorBinding = read(previousFile), priorReplacement = read(workspaceReplacementFile());
+    if (priorReplacement !== null && options.replacingWorkspace === undefined)
+        throw Error('An unfinished replacement exists; resume or abandon it before setup. Existing setup preserved');
+    const unchangedBinding = () => {
+        if (read(previousFile) !== priorBinding)
+            throw Error('The workspace binding changed during setup; existing setup preserved. Run the setup command again');
+        if (read(workspaceReplacementFile()) !== priorReplacement)
+            throw Error('The unfinished replacement changed during setup; existing setup preserved. Review it with setup-tunnel --resume');
+    };
+    if (priorBinding !== null) {
+        const previous = JSON.parse(priorBinding);
         if (previous.workspaceId !== payload.challenge.workspaceId && options.replacingWorkspace !== previous.workspaceId)
             throw Error('This host is already associated with another workspace');
-        const priorOrigin = validateAccountOrigin(previous.appOrigin ?? 'https://app.ours.network');
+        const priorOrigin = validateAccountOrigin(previous.appOrigin);
         migrating = priorOrigin !== appOrigin && options.replacingWorkspace !== previous.workspaceId;
         if (migrating && !options.migrateAppOrigin)
             throw Error('Account origin change requires explicit --migrate-app-origin and a fresh setup payload');
@@ -287,7 +306,7 @@ export async function enrollWorkspace(payload, configuration = defaultConfigPath
         throw Error('Bound Messenger identity unavailable');
     // An installation that ran Messenger as the Human root and now runs it as the person's own identity keeps its managed Owner entry, moved to that identity.
     const moved = Boolean(loaded.rooms) && !lost && !!identity.root && !same(loaded.rooms.owner.expected_cid, identity.cid) && managedRootOwner(resolve(configuration), loaded.rooms, identity.root)
-        && (options.replacingWorkspace !== undefined || JSON.parse(readFileSync(previousFile, 'utf8')).serverCid?.toUpperCase() === payload.serverCid.toUpperCase());
+        && (options.replacingWorkspace !== undefined || JSON.parse(priorBinding).serverCid?.toUpperCase() === payload.serverCid.toUpperCase());
     if (options.preserveProfile && identity.preserveProfile !== true)
         throw Error('Existing-host setup requires Messenger profile-preservation support; update the host Messenger before retrying');
     if (!options.preserveProfile && (payload.fullName?.trim() || !payload.name?.trim() || !payload.surname?.trim()) && !identity.optionalWorkspaceProfileV1)
@@ -327,6 +346,7 @@ export async function enrollWorkspace(payload, configuration = defaultConfigPath
             throw Error('Invalid replacement proof receipt');
         }
     }
+    withSynchronousFileLock(workspaceBindingLock(), unchangedBinding);
     if (identity.root) {
         if (!options.preserveProfile)
             await request('identity/profile', { fullName: fullName ?? null, name: name ?? null, surname: surname ?? null });
@@ -376,26 +396,31 @@ export async function enrollWorkspace(payload, configuration = defaultConfigPath
             await new Promise(resolve => setTimeout(resolve, 500));
         }
     }
-    replaceFileAtomically(inviteFile, result.ownerInvite + '\n', 0o600);
-    options.afterInvitation?.();
-    const split = splitRootFor(configuration);
-    mkdirSync(split, { recursive: true, mode: 0o700 });
-    if (!loaded.rooms)
-        replaceFileAtomically(configuration, readFileSync(configuration, 'utf8') + '\n' + stringify(generatedRooms(ownerCid, inviteFile)), 0o600);
-    else if (lost && loaded.rooms.owner.expected_cid.toLowerCase() !== ownerCid.toLowerCase())
-        replaceFileAtomically(configuration, `api_version: ${GENERATED_VERSION}\n\n` + stringify(generatedRooms(ownerCid, inviteFile)), 0o600);
-    else if (moved) {
-        // The invitation above and this entry are two files. A setup interrupted between them leaves the entry naming the root,
-        // which is this same case again: running setup once more writes both.
-        const document = parseDocument(readFileSync(configuration, 'utf8'));
-        document.setIn(['rooms', 'owner', 'expected_cid'], ownerCid);
-        replaceFileAtomically(configuration, document.toString(), 0o600);
-    }
-    if (payload.connectorToken !== undefined)
-        replaceFileAtomically(join(dir, 'connector'), payload.connectorToken + '\n', 0o600);
     const origin = `https://${payload.hostname}`;
-    replaceFileAtomically(join(dir, 'tunnel.json'), JSON.stringify({ origin, tokenFile: join(dir, 'connector') }) + '\n', 0o600);
-    replaceFileAtomically(previousFile, JSON.stringify({ workspaceId: payload.challenge.workspaceId, hostWorkspaceId, appOrigin, serverCid: payload.serverCid.toUpperCase(), ...(identity.root ? { proofRootCid: identity.root.cid } : {}) }) + '\n', 0o600);
+    // Local files commit together under the binding lock, after rechecking the binding this setup decided
+    // on, so a stale concurrent setup refuses before changing any of them.
+    withSynchronousFileLock(workspaceBindingLock(), () => {
+        unchangedBinding();
+        replaceFileAtomically(inviteFile, result.ownerInvite + '\n', 0o600);
+        options.afterInvitation?.();
+        const split = splitRootFor(configuration);
+        mkdirSync(split, { recursive: true, mode: 0o700 });
+        if (!loaded.rooms)
+            replaceFileAtomically(configuration, readFileSync(configuration, 'utf8') + '\n' + stringify(generatedRooms(ownerCid, inviteFile)), 0o600);
+        else if (lost && loaded.rooms.owner.expected_cid.toLowerCase() !== ownerCid.toLowerCase())
+            replaceFileAtomically(configuration, `api_version: ${GENERATED_VERSION}\n\n` + stringify(generatedRooms(ownerCid, inviteFile)), 0o600);
+        else if (moved) {
+            // The invitation above and this entry are two files. A setup interrupted between them leaves the entry naming the root,
+            // which is this same case again: running setup once more writes both.
+            const document = parseDocument(readFileSync(configuration, 'utf8'));
+            document.setIn(['rooms', 'owner', 'expected_cid'], ownerCid);
+            replaceFileAtomically(configuration, document.toString(), 0o600);
+        }
+        if (payload.connectorToken !== undefined)
+            replaceFileAtomically(join(dir, 'connector'), payload.connectorToken + '\n', 0o600);
+        replaceFileAtomically(join(dir, 'tunnel.json'), JSON.stringify({ origin, tokenFile: join(dir, 'connector') }) + '\n', 0o600);
+        replaceFileAtomically(previousFile, JSON.stringify({ workspaceId: payload.challenge.workspaceId, hostWorkspaceId, appOrigin, serverCid: payload.serverCid.toUpperCase(), ...(identity.root ? { proofRootCid: identity.root.cid } : {}) }) + '\n', 0o600);
+    });
     loadConfig(configuration);
     return { origin, hostWorkspaceId, rootCid: result.rootCid };
 }

package/dist/workspace-replacement.js

@@ -3,20 +3,21 @@ import { existsSync, lstatSync, readFileSync, rmSync } from 'node:fs';
 import { join, resolve } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { validateAccountOrigin } from './account-origin.js';
-import { replaceFileAtomically } from './atomic-file.js';
-import { stateRoot } from './paths.js';
+import { replaceFileAtomically, withSynchronousFileLock } from './atomic-file.js';
+import { stateRoot, workspaceBindingLock, workspaceReplacementFile } from './paths.js';
 import { decodeWorkspacePayload, enrollWorkspace, unregisterWorkspace, checkWorkspaceConnector } from './workspace-enrollment.js';
 import { WorkspaceDeviceStore } from './web/workspace-devices.js';
 import { webControlPath } from './web/control.js';
 import { WebServiceManager } from './web/service.js';
 const workspaceDir = () => join(stateRoot(), 'workspace');
-const replacementPath = () => join(workspaceDir(), 'replacement.json');
+const replacementPath = workspaceReplacementFile;
 const opaque = /^[\w-]{43}$/;
 function binding(value) {
-    if (!value || !opaque.test(value.workspaceId) || !opaque.test(value.hostWorkspaceId) || (value.serverCid !== undefined && !/^[a-f0-9]{64}$/i.test(value.serverCid))
-        || (value.proofRootCid !== undefined && !/^[a-f0-9]{64}$/i.test(value.proofRootCid)))
+    const text = (id, pattern) => typeof id === 'string' && pattern.test(id);
+    if (!value || typeof value !== 'object' || !text(value.workspaceId, opaque) || !text(value.hostWorkspaceId, opaque) || (value.serverCid !== undefined && !text(value.serverCid, /^[a-f0-9]{64}$/i))
+        || (value.proofRootCid !== undefined && !text(value.proofRootCid, /^[a-f0-9]{64}$/i)))
         throw Error('Existing workspace binding is invalid; restore it before tunnel setup');
-    return { ...value, appOrigin: validateAccountOrigin(value.appOrigin ?? 'https://app.ours.network') };
+    return { ...value, appOrigin: validateAccountOrigin(value.appOrigin) };
 }
 export function readWorkspaceBinding() {
     const file = join(workspaceDir(), 'binding.json');
@@ -53,7 +54,7 @@ export async function confirmWorkspaceReplacement(previous, explicit = false, ef
     let hostname = '';
     try {
         const tunnel = JSON.parse(readFileSync(join(workspaceDir(), 'tunnel.json'), 'utf8'));
-        if (typeof tunnel.origin === 'string' && /^https:\/\/[a-z0-9][a-z0-9-]{2,60}\.ours-tunnel\.com$/.test(tunnel.origin))
+        if (typeof tunnel.origin === 'string' && validateAccountOrigin(tunnel.origin))
             hostname = ` (${new URL(tunnel.origin).hostname})`;
     }
     catch { }
@@ -84,7 +85,7 @@ export async function confirmWorkspaceReplacement(previous, explicit = false, ef
     return false;
 }
 export function saveWorkspaceReplacement(record) {
-    replaceFileAtomically(replacementPath(), JSON.stringify(record) + '\n', 0o600);
+    withSynchronousFileLock(workspaceBindingLock(), () => replaceFileAtomically(replacementPath(), JSON.stringify(record) + '\n', 0o600));
 }
 export function readWorkspaceReplacement() {
     const file = replacementPath();
@@ -110,7 +111,7 @@ export function readWorkspaceReplacement() {
     record.payload = decodeWorkspacePayload(Buffer.from(JSON.stringify(record.payload)).toString('base64url'), { allowExpired: true });
     return record;
 }
-export function clearWorkspaceReplacement() { rmSync(replacementPath(), { force: true }); }
+export function clearWorkspaceReplacement() { withSynchronousFileLock(workspaceBindingLock(), () => rmSync(replacementPath(), { force: true })); }
 /** Explicit recovery after the user removes an unsuccessful successor in the App. */
 export function discardRetiredWorkspaceReplacement() {
     const record = readWorkspaceReplacement(), current = readWorkspaceBinding();
@@ -132,9 +133,26 @@ export async function beginWorkspaceReplacement(previous, payload, configuration
     if (!requiresWorkspaceReplacement(previous, { workspaceId: payload.challenge.workspaceId, appOrigin: payload.appOrigin, serverCid: payload.serverCid }))
         throw Error('The same workspace must never be retired');
     checkReplacementService(configuration);
+    // The record is created only for the binding this decision was made on, and only if no other
+    // replacement or setup changed the binding or the record meanwhile; enrollment checks the same pair.
+    const bindingFile = join(workspaceDir(), 'binding.json'), current = () => existsSync(bindingFile) ? readFileSync(bindingFile, 'utf8') : null;
+    const unchanged = (bytes) => {
+        if (current() !== bytes)
+            throw Error('The workspace binding changed during setup; existing setup preserved. Run the setup command again');
+        if (existsSync(replacementPath()))
+            throw Error('Another replacement started during setup; existing setup preserved. Review it with setup-tunnel --resume');
+    };
+    const before = withSynchronousFileLock(workspaceBindingLock(), () => {
+        const bytes = current();
+        unchanged(bytes);
+        const now = readWorkspaceBinding();
+        if (!now || now.workspaceId !== previous.workspaceId || now.hostWorkspaceId !== previous.hostWorkspaceId || now.appOrigin !== previous.appOrigin || now.serverCid?.toUpperCase() !== previous.serverCid?.toUpperCase())
+            throw Error('The workspace binding changed during setup; existing setup preserved. Run the setup command again');
+        return bytes;
+    });
     const record = { version: 2, previous: previous, payload, configuration: resolve(configuration), operationNonce: randomBytes(32).toString('base64url'), dispatchAttempted: false, operationExpiresAt: Date.now() + 86400000 - 5 * 60000 };
     record.rootCid = await (effects.preflight ?? unregisterWorkspace)(record.previous, payload, record.operationNonce, effects.attach, { checkOnly: true, operationExpiresAt: record.operationExpiresAt });
-    saveWorkspaceReplacement(record);
+    withSynchronousFileLock(workspaceBindingLock(), () => { unchanged(before); replaceFileAtomically(replacementPath(), JSON.stringify(record) + '\n', 0o600); });
     return record;
 }
 /** Abandon only after a private receipt confirms no deletion and dispatch was unsent or terminally rejected. */

package/docs/conversation-stream.md

@@ -188,3 +188,9 @@ explicit recovery and unsupported-host fallback. DOM mutation and fixture latenc
 measurements have no claim about real-provider inference or physical-device audio.
 The App and Fleet changes require coordinated upstream delivery; source qualification
 does not establish that installed or serving packages contain them.
+
+## Full resource delivery qualification
+
+Directory, configuration/definitions, previews, provider/status, layout and admitted-operation views share the authenticated ephemeral resource connection with per-view epochs. Complete ready requires the canonical subscribed payload; a heartbeat does not certify a failed upstream watcher. User commands remain HTTP. Controller, voice and selected-daemon health are independent owners. The selected-daemon health deadline passes its cancellation signal through the public SDK selection/request API, cancelling underlying HTTP I/O as well as retiring the result.
+
+The matching App source qualification composes the existing ACP/Codex browser fixture and records sixty-second healthy windows separately from initial/history/recovery/command/health/lease/long-poll traffic. Unit and HTTP producer checks are not proof of every rendered resource combination or installed deployment. Preserve existing room-layout suite sources and qualify released service/dependency versions separately.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.2.0-nightly.70",
+  "version": "1.2.0-nightly.72",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",