@ours.network/fleet 1.2.0-nightly.3 → 1.2.0-nightly.5

package/dist/docs.js

@@ -253,20 +253,15 @@ records receive a bounded grace so a not-yet-registered transient unit cannot be
 mistaken for a stopped one. Stale recorded supervisors are reclaimed in bounded
 batches by moving their state to the same recovery archive, never by blind deletion.
 
-Every temporary role creates a new session-owned identity by calling ours MCP
-\`create_temporary_identity\` with its exact assigned name. It never binds a
-pre-existing identity and never falls back to permanent \`create_identity\`.
-Fleet does not inspect, preserve, or provision an ours identity for temporary
-spawn; creation belongs exclusively to the launched temporary agent session.
-Collisions, missing tool support, and creation errors stop safely without
-force-adopting or deleting identity state. Permanent roles
-are provisioned by fleet before launch and never delegate normal identity
-creation to the harness.
-
-The temporary supervisor treats its first positive identity observation as the
-lifecycle readiness gate: a cold harness may take as long as needed to read its
-briefing and bind, without a fixed first-bind retirement timer. After readiness,
-only sustained authoritative absence closes the role. Unreachable, malformed, or
+The Fleet supervisor creates and binds the assigned identity before the harness
+starts. Temporary identities survive harness reconnects and are released only when
+the logical run ends. Permanent identities remain available after the supervisor
+releases ownership. Agents receive ready tools; no model-owned identity bootstrap
+or onboarding skill is required.
+
+The temporary supervisor provisions identity and verifies room readiness before
+starting the harness. After readiness, only sustained authoritative absence
+closes the role. Unreachable, malformed, or
 valid-but-empty daemon indexes are ambiguous and reset closure debounce rather
 than becoming cleanup authority.
 
@@ -454,10 +449,10 @@ tasks:
 \`\`\`
 
 Fleet launches each template member with a dedicated one-time Cowork invite.
-The generated temporary-agent briefing contains the exact identity name, invite,
-Cowork role, and task. The agent creates that identity itself with ours MCP
-\`create_temporary_identity\`, accepts the invite with \`add_contact\`, and starts
-work immediately. A room is ready only after the Cowork room (and its task, when
+The supervisor accepts the startup invite and verifies the provisioned identity CID
+in the authenticated room seat before starting the model. The generated briefing
+contains the assigned identity, room, role and task, without invite material.
+A room is ready only after the Cowork room (and its task, when
 task-bound) is durably active, every configured member seat is authenticated and active with its matching
 live Fleet launch, and the configured Owner seat is active when owner attachment is
 enabled. There is no briefing hash, startup ACK, or separate role-briefing readiness
@@ -480,8 +475,8 @@ Set \`room.anonymous: true\` on a room template, or pass \`--anonymous\` to
 \`task create\`, \`task start\`, \`task work\`, or \`room create\`, to create an
 anonymous Cowork room. \`--no-anonymous\` explicitly overrides an anonymous
 template. Fleet records the resolved value before room creation so retries keep
-the same choice. Temporary members of an anonymous room are instructed to call
-\`create_temporary_identity\` with \`expose_local=false\`. Their generated briefings
+the same choice. The supervisor creates anonymous room members with local contact-book exposure
+disabled. Their generated briefings
 do not disclose or compare an Owner participant CID. A participant-originated
 instruction has Owner authority only when the authenticated Cowork room envelope
 attributes that participant seat the exact \`Owner\` role. Literal text, display

package/dist/doctor.d.ts

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

package/dist/doctor.js

@@ -1,4 +1,5 @@
-import { userInfo } from 'node:os';
+import { join } from 'node:path';
+import { userInfo, homedir } from 'node:os';
 import { existsSync, readFileSync } from 'node:fs';
 import { attachOursClient, } from '@ours.network/sdk/client';
 import { realExec } from './exec.js';
@@ -272,21 +273,39 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
         }
         catch { /* state dir may not exist yet */ }
     }
+    let managedSelection = false;
     try {
-        const client = await attachDaemon({
-            env: process.env,
+        // Mark explicit selection before validation so a damaged managed profile does
+        // not produce advice to start an unrelated local daemon.
+        managedSelection = process.env.OURS_CONFIG !== undefined
+            || existsSync(join(process.env.HOME || homedir(), '.ours-client', 'profile.json'));
+        const selected = readClientProfile(process.env);
+        managedSelection = selected !== undefined;
+        const client = await attachDaemon(selected ? {
+            endpoint: selected.endpoint, expectedInstanceId: selected.expectedInstanceId,
+            credentialPath: selected.credentialPath, env: {}, sessionMode: 'external',
             leaseToken: `ours-fleet-doctor-${process.pid}`,
-            clientPid: process.pid,
+        } : {
+            env: process.env, leaseToken: `ours-fleet-doctor-${process.pid}`, clientPid: process.pid,
         });
-        const info = await client.version();
-        if (info.name !== 'ours' || typeof info.version !== 'string')
-            throw new Error('the selected endpoint did not return a valid ours daemon identity');
-        checks.push({ name: 'ours daemon', ok: true, detail: `running (${info.version})` });
+        let daemonVersion;
+        try {
+            const info = await client.version();
+            if (info.name !== 'ours' || typeof info.version !== 'string')
+                throw new Error('the selected endpoint did not return a valid ours daemon identity');
+            daemonVersion = info.version;
+        }
+        finally {
+            await client.close();
+        }
+        checks.push({ name: 'ours daemon', ok: true, detail: `running (${daemonVersion})` });
     }
     catch (error) {
         checks.push({
             name: 'ours daemon', ok: false,
-            detail: `not reachable through the SDK — start it with: ours-daemon start `
+            detail: (managedSelection
+                ? 'selected client profile failed — check its endpoint, instance and issued credential '
+                : 'not reachable through the SDK — start it with: ours-daemon start ')
                 + `[${error?.message ?? String(error)}]`,
         });
     }

package/dist/fleet-command-audit.js

@@ -132,7 +132,7 @@ export const fleetProxyTopLevelInventory = Object.freeze({
         'up', 'down', 'restart', 'force-restart', 'attach', 'send', 'loops', 'owner-channel',
         'watchdog-run', 'watchdog-report', 'rm', 'init', 'web',
     ], denied: [...DENIED],
-    hidden: ['_run', '_run-temp', '_run-watchdog', '_run-watchdogs'], aliases: ['man'],
+    hidden: ['_run', '_run-temp', '_run-temp-worker', '_run-watchdog', '_run-watchdogs'], aliases: ['man'],
 });
 const globalValueOptions = new Set(['-c', '--configuration']);
 /** Classify before Commander parsing. Unknown and internal paths fail closed. */

package/dist/harness/agent-session.d.ts

@@ -1,3 +1,4 @@
+import type { ManagedHarnessOurs } from '../agent-ours/harness.js';
 import type { CommonPermissions, FleetPermissionMode, ResolvedRole } from '../config.js';
 import type { AgentSession } from '../session/types.js';
 import type { Launch, SessionPrep } from './types.js';
@@ -22,6 +23,7 @@ export interface AgentSessionConfigSelection {
     value: string;
 }
 export interface AgentSessionStartOptions {
+    managedOurs?: ManagedHarnessOurs;
     role: ResolvedRole;
     prep: SessionPrep;
     launch: PreparedAgentSessionLaunch;

package/dist/harness/claude-code-session.js

@@ -1,3 +1,4 @@
+import { managedClaudeMeta } from '../agent-ours/harness.js';
 import { AcpSession } from '../session/acp.js';
 import { acpAdapterState, } from './acp-session-transport.js';
 /** Explicit Claude Code implementation of Fleet's shared agent-session factory. */
@@ -25,8 +26,9 @@ export class ClaudeCodeAgentSessionAdapter {
             argv: launch.argv, cwd: options.cwd, env: launch.env,
             stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
             modeId: this.strategy.permissionModeId(role),
-            mcpServers: this.strategy.mcpServers(role),
-            sessionMeta: this.strategy.sessionMeta(role, prep),
+            mcpServers: options.managedOurs ? [...(this.strategy.mcpServers(role) ?? []).filter(s => s.name !== 'ours'), options.managedOurs.server] : this.strategy.mcpServers(role),
+            inheritEnvironment: options.managedOurs ? false : undefined,
+            sessionMeta: options.managedOurs ? managedClaudeMeta(this.strategy.sessionMeta(role, prep)) : this.strategy.sessionMeta(role, prep),
             configSelections: this.strategy.sessionConfigSelections(role),
             permissionMode: options.permissionMode,
             permissionMetadataSource: acpAdapterState(launch.adapterState).permissionMetadataSource,

package/dist/harness/codex-session.js

@@ -23,6 +23,12 @@ export class CodexAgentSessionAdapter {
     }
     start(options) {
         const { role, prep, launch } = options;
+        const original = this.strategy.nativeConfig(role) ?? {};
+        const managed = options.managedOurs?.native;
+        const config = managed ? { ...original, ...managed,
+            mcp_servers: { ...(original.mcp_servers ?? {}), ...(managed.mcp_servers ?? {}) },
+            plugins: { ...(original.plugins ?? {}), ...(managed.plugins ?? {}) },
+        } : original;
         if (role.session === 'codex-app-server')
             return this.nativeTransport({
                 name: role.name, argv: launch.argv, cwd: options.cwd, env: launch.env,
@@ -31,7 +37,7 @@ export class CodexAgentSessionAdapter {
                 model: role.model, effort: role.effort,
                 approvalPolicy: this.strategy.approvalPolicy(role),
                 sandbox: this.strategy.sandbox(role),
-                config: this.strategy.nativeConfig(role),
+                config,
                 addDirs: this.strategy.addDirs(role),
                 log: options.log,
             });
@@ -40,7 +46,8 @@ export class CodexAgentSessionAdapter {
             argv: launch.argv, cwd: options.cwd, env: launch.env,
             stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
             modeId: this.strategy.permissionModeId(role),
-            mcpServers: this.strategy.mcpServers(role),
+            mcpServers: options.managedOurs ? [...(this.strategy.mcpServers(role) ?? []).filter(s => s.name !== 'ours'), options.managedOurs.server] : this.strategy.mcpServers(role),
+            inheritEnvironment: options.managedOurs ? false : undefined,
             sessionMeta: this.strategy.sessionMeta(role, prep),
             configSelections: this.strategy.sessionConfigSelections(role),
             permissionMode: options.permissionMode,

package/dist/harness/hermes-session.js

@@ -53,6 +53,12 @@ export class HermesAgentSessionAdapter {
         // composition; no second ambient merge may reintroduce provider secrets.
         const env = hermesChildEnvironment(role, preparedHome(prep), launch.env, launch.env);
         delete env.OURS_AUTOSTART;
+        if (options.managedOurs) {
+            for (const key of Object.keys(env))
+                if (key.startsWith('OURS_') && !key.startsWith('OURS_FLEET_'))
+                    delete env[key];
+            Object.assign(env, { FLEET_OURS_MANAGED: '1' });
+        }
         await this.checks.preflight?.(options, env);
         const nativeProvider = await this.checks.expectedProvider(role, prep);
         if (typeof nativeProvider !== 'string' || !nativeProvider.trim())
@@ -68,7 +74,7 @@ export class HermesAgentSessionAdapter {
             permissions: options.permissions, modeId, requireMode: true,
             permissionMode: { fleetMode: options.permissionMode.fleetMode, nativeMode: modeId },
             permissionTimeoutMs: 50_000,
-            mcpServers: hermesMcpServers(role, env),
+            mcpServers: options.managedOurs ? [...hermesMcpServers(role, env).filter(s => s.name !== 'ours'), options.managedOurs.server] : hermesMcpServers(role, env),
             scrubObsoleteOursAutostart: true,
             validateStartupResponse: async (initialized, created) => {
                 await this.checks.validateArtifact(initialized);

package/dist/rooms-tasks/cowork-adapter.js

@@ -8,6 +8,8 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join, resolve } from 'node:path';
 import { createConnection } from 'node:net';
+import { readClientProfile } from '../client-profile.js';
+import { coworkHttpCall } from './cowork-http.js';
 const RPC_VERSION = 1;
 const DEFAULT_TIMEOUT_MS = 30_000;
 const MAX_RESPONSE_BYTES = 4 * 1024 * 1024;
@@ -275,10 +277,15 @@ function rpcCall(socketPath, method, params, timeoutMs, connect) {
     });
 }
 export function createCoworkAdapter(options = {}) {
-    const socketPath = resolveCoworkSocketPath(options);
+    const env = options.env ?? process.env;
+    const explicitLocal = options.socketPath !== undefined || options.configPath !== undefined
+        || env.OURS_COWORK_CONFIG !== undefined || !!env.OURS_COWORK_STATE_DIR;
+    const profile = explicitLocal ? undefined : readClientProfile({ ...env, HOME: options.home ?? env.HOME });
+    const remote = profile?.serverUrl ? profile : undefined;
+    const socketPath = remote ? undefined : resolveCoworkSocketPath(options);
     const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
     const connect = options.connect ?? ((path) => createConnection(path));
-    const call = (method, params) => rpcCall(socketPath, method, params, timeoutMs, connect);
+    const call = (method, params) => remote ? coworkHttpCall(remote, method, params, timeoutMs) : rpcCall(socketPath, method, params, timeoutMs, connect);
     return {
         async available() {
             try {

package/dist/rooms-tasks/cowork-http.d.ts

@@ -0,0 +1,3 @@
+import type { ExplicitClientProfile } from '../client-profile.js';
+/** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
+export declare function coworkHttpCall(profile: ExplicitClientProfile, method: string, params: Record<string, unknown>, timeoutMs: number): Promise<unknown>;

package/dist/rooms-tasks/cowork-http.js

@@ -0,0 +1,70 @@
+import { randomUUID } from 'node:crypto';
+import { attachOursClient } from '@ours.network/sdk/client';
+import { readPrivateFile } from '@ours.network/sdk/connector';
+import { CoworkProtocolError, CoworkUnavailableError } from './cowork-adapter.js';
+/** Same RPC protocol as the local socket; never replay a possibly delivered mutation. */
+export async function coworkHttpCall(profile, method, params, timeoutMs) {
+    const id = randomUUID();
+    const signal = AbortSignal.timeout(timeoutMs);
+    const body = JSON.stringify({ version: 1, id, method, params });
+    if (Buffer.byteLength(body) > 1024 * 1024)
+        throw new CoworkProtocolError(method, 'request exceeded 1 MiB');
+    try {
+        const client = await attachOursClient({ endpoint: profile.endpoint, expectedInstanceId: profile.expectedInstanceId,
+            credentialPath: profile.credentialPath, sessionMode: 'external', leaseToken: `fleet-cowork-check-${id}`, env: {}, requestSignal: signal });
+        await client.close();
+        const token = readPrivateFile(profile.credentialPath, 4096).toString('utf8').trim();
+        const response = await fetch(profile.serverUrl + '/cowork/management/rpc', {
+            method: 'POST', redirect: 'error', signal,
+            headers: { 'content-type': 'application/json', 'x-ours-api-token': token },
+            body,
+        });
+        if (response.status === 401 || response.status === 403) {
+            await response.body?.cancel();
+            throw new CoworkProtocolError(method, 'server credential was rejected', 'unauthorized');
+        }
+        const reader = response.body?.getReader();
+        if (!reader)
+            throw new CoworkProtocolError(method, 'empty HTTP response');
+        const chunks = [];
+        let size = 0;
+        try {
+            for (;;) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                size += value.length;
+                if (size > 4 * 1024 * 1024)
+                    throw new CoworkProtocolError(method, 'response exceeded 4 MiB');
+                chunks.push(value);
+            }
+        }
+        finally {
+            await reader.cancel();
+        }
+        let rpc;
+        try {
+            rpc = JSON.parse(Buffer.concat(chunks).toString('utf8'));
+        }
+        catch {
+            throw new CoworkProtocolError(method, 'server returned malformed JSON');
+        }
+        if (!rpc || Array.isArray(rpc) || rpc.version !== 1 || rpc.id !== id
+            || Object.hasOwn(rpc, 'result') === Object.hasOwn(rpc, 'error'))
+            throw new CoworkProtocolError(method, 'server returned an invalid RPC response');
+        if (Object.hasOwn(rpc, 'error')) {
+            const error = rpc.error;
+            if (!error || typeof error.code !== 'string' || typeof error.message !== 'string')
+                throw new CoworkProtocolError(method, 'server returned an invalid RPC error');
+            throw new CoworkProtocolError(method, error.message, error.code);
+        }
+        if (!response.ok)
+            throw new CoworkProtocolError(method, `management answered HTTP ${response.status}`);
+        return rpc.result;
+    }
+    catch (error) {
+        if (error instanceof CoworkProtocolError)
+            throw error;
+        throw new CoworkUnavailableError('Cowork HTTP management failed; check the selected server and credential', { cause: error });
+    }
+}

package/dist/rooms-tasks/provision.js

@@ -1,3 +1,4 @@
+import { readRoomReadiness } from '../agent-ours/service.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
@@ -149,8 +150,7 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
             && (startup.anonymous ?? false) === anonymous
             && sha256Text(startup.task ?? '') === taskSha
             && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
-            && typeof startup.invite === 'string'
-            && startup.invite.length > 0;
+            && startup.invite === '';
     }
     catch {
         return false;
@@ -345,7 +345,14 @@ function reconcileMemberSeats(roomId, members, observed, ownerSeatCid) {
         && seat.seat_state === 'active');
     const seats = current.member_seats.map(seat => {
         const member = members.find(candidate => candidate.name === seat.role_name);
+        const readiness = readRoomReadiness(current.room_identity_cid, member.name);
+        if (!readiness || readiness.room !== roomId || readiness.invite !== seat.invite_id) {
+            complete = false;
+            return seat;
+        }
         const found = exactCoworkSeat(observed, member, seat.invite_id);
+        if (found && found.identity_cid !== readiness.cid)
+            throw new Error('Cowork seat CID does not match supervisor provisioned identity');
         if (!found || found.seat_state !== 'active') {
             complete = false;
             return seat;

package/dist/runner.d.ts

@@ -1,3 +1,4 @@
+import { prepareManagedAgent, releaseManagedAgent } from './agent-ours/service.js';
 import { type ResolvedRole } from './config.js';
 import { type MonitorHandle, type MonitorOpts, type FetchLike } from './monitor.js';
 import { type DaemonGenerationProbe } from './daemon-recovery.js';
@@ -9,6 +10,8 @@ import { type OwnerChannelHandle, type OwnerChannelOptions } from './owner-chann
 import { type OwnerBinderLease } from './owner-channel/binder.js';
 import { ScheduledLoopManager, type ScheduledLoopManagerHandle } from './loops/manager.js';
 export interface RunnerDeps {
+    prepareAgentOurs: typeof prepareManagedAgent;
+    releaseAgentOurs: typeof releaseManagedAgent;
     exec: Exec;
     cpuDelegated(): boolean;
     isAlive(pid: number): boolean;
@@ -168,6 +171,7 @@ export declare function runOnce(name: string, opts?: {
     temp?: boolean;
     configPath?: string;
     allowResumeRotation?: boolean;
+    identityLifetime?: 'permanent' | 'temporary';
 }, partialDeps?: Partial<RunnerDeps>): Promise<AttemptResult>;
 /**
  * The persistent supervisor for one permanent role: run child sessions in a