@ours.network/fleet 0.18.1 → 0.19.0-nightly.10

package/dist/config.d.ts

@@ -11,9 +11,6 @@ export interface WorklogPolicy {
     keep_tail_kb: number;
     max_archives: number;
 }
-export type WorklogPolicyInput = Partial<WorklogPolicy> | false;
-/** Conservative built-in policy; `worklog: false` is the explicit opt-out. */
-export declare const DEFAULT_WORKLOG_POLICY: Readonly<WorklogPolicy>;
 export interface AuthProxyConfig {
     kind: 'anthropic';
     base_url: string;
@@ -133,10 +130,10 @@ export interface RoleConfig {
     isolation?: IsolationConfig;
     monitor?: Partial<MonitorConfig>;
     owner_channel?: OwnerChannelConfigInput;
-    worklog?: WorklogPolicyInput;
+    worklog?: WorklogPolicy;
     auth_proxy?: Partial<AuthProxyConfig>;
 }
-export interface ResolvedRole extends Omit<RoleConfig, 'model' | 'owner_channel' | 'worklog'> {
+export interface ResolvedRole extends Omit<RoleConfig, 'model' | 'owner_channel'> {
     name: string;
     harness: string;
     session: SessionBackendId;
@@ -168,6 +165,17 @@ export interface FleetConfig {
     diagnostics: ConfigDiagnostic[];
     watchdogs: ResolvedWatchdog[];
     loops: ResolvedLoop[];
+    rooms?: import('./rooms-tasks/types.js').RoomsConfig;
+    roomTemplates?: import('./rooms-tasks/types.js').RoomTemplatesConfig;
+    tasks?: import('./rooms-tasks/types.js').TasksConfig;
+    /** SHA-256 fingerprint of the resolved owner invite (never the invite itself). */
+    ownerInviteFingerprint?: string;
+    /**
+     * Resolved owner invite for immediate private-IPC use only. This property is
+     * deliberately non-enumerable so config dumps and JSON output cannot expose
+     * the bearer credential.
+     */
+    ownerInvite?: string;
 }
 export declare class ConfigError extends Error {
 }
@@ -196,7 +204,7 @@ export declare function canonicalCid(value: string): string;
 export declare function resolveOwnerChannelConfig(defaults: unknown, role: OwnerChannelConfigInput | undefined, session: SessionBackendId, file?: string, name?: string): OwnerChannelConfig | undefined;
 export declare function resolveModelChain(model: string | undefined, chain: string[] | undefined, file?: string, name?: string): string[] | undefined;
 export declare function resolveAuthProxy(defaults: unknown, role: Partial<AuthProxyConfig> | undefined, file?: string, name?: string): AuthProxyConfig | undefined;
-export declare function resolveWorklogPolicy(defaults: unknown, role: WorklogPolicyInput | undefined, file?: string, name?: string): WorklogPolicy | undefined;
+export declare function resolveWorklogPolicy(defaults: unknown, role: WorklogPolicy | undefined, file?: string, name?: string): WorklogPolicy | undefined;
 export declare function resolvePermissions(defaults: unknown, role: Partial<CommonPermissions> | undefined, file?: string, name?: string): CommonPermissions;
 /**
  * Merge `defaults.monitor` under the role's own `monitor:` key-by-key, validate the

package/dist/config.js

@@ -4,17 +4,11 @@ import { agentDir, defaultConfigPath, fleetDDir, home } from './paths.js';
 import { parseFleetDocument, } from './config-yaml.js';
 import { harnessRuntimeDir, resolveIsolation, validateIsolationConfig, } from './isolation/policy.js';
 import { getAdapter } from './harness/registry.js';
-import { resolveRoleModelEnv } from './model-env.js';
 import { resolveWatchdogs } from './watchdog/config.js';
 import { resolveLoops } from './loops/config.js';
+import { validateRoomsConfig, validateTasksConfig, validateRoomTemplatesConfig, } from './rooms-tasks/config.js';
 import { CAPABILITIES, CAP_MONITOR_INTERRUPT_AFTER_TOOL } from './capabilities.js';
 import { runningLabel } from './provenance.js';
-/** Conservative built-in policy; `worklog: false` is the explicit opt-out. */
-export const DEFAULT_WORKLOG_POLICY = Object.freeze({
-    max_kb: 1024,
-    keep_tail_kb: 256,
-    max_archives: 12,
-});
 /** The 8 content-free event types the ours daemon appends to notifications.log. */
 export const NOTIFY_EVENT_TYPES = [
     'message_received', 'file_received', 'sibling_contact_added', 'local_contact_request',
@@ -171,9 +165,10 @@ export function loadConfig(configPath, options = {}) {
             const parsed = parseFleetDocument(p, readFileSync(p, 'utf8'), options.yamlMode);
             const doc = parsed.value;
             diagnostics.push(...parsed.diagnostics);
-            const extra = Object.keys(doc).filter(k => k !== 'roles');
+            const FLEET_D_ALLOWED = ['roles', 'rooms', 'room_templates', 'tasks'];
+            const extra = Object.keys(doc).filter(k => !FLEET_D_ALLOWED.includes(k));
             if (extra.length)
-                throw new ConfigError(`${p}: fleet.d files may only define roles: (found: ${extra.join(', ')})`);
+                throw new ConfigError(`${p}: fleet.d files may only define ${FLEET_D_ALLOWED.join(', ')}: (found: ${extra.join(', ')})`);
             docs.push({ file: p, doc });
             files.push(p);
         }
@@ -224,23 +219,17 @@ export function loadConfig(configPath, options = {}) {
             const harness = r.harness ?? defaults.harness ?? 'claude-code';
             const defaultHarness = defaults.harness ?? 'claude-code';
             const inheritsModelDefaults = harness === defaultHarness && r.model !== null;
-            if (authProxy && harness !== 'claude-code')
-                throw new ConfigError(`${file}: role '${name}' auth_proxy is supported only by claude-code`);
-            // Environment and runtime model are resolved together so `model:` and the
-            // harness's model pin can never disagree (see src/model-env.ts).
-            const modelEnv = resolveRoleModelEnv({
-                harness,
-                model: resolveRoleModel(r.model, r.harness, defaults),
-                modelWasExplicit: r.model !== undefined,
-                defaultsEnv: (defaults.env ?? {}),
-                roleEnv: r.env,
-                ...(authProxy ? { authProxyBaseUrl: authProxy.base_url } : {}),
-            }, message => new ConfigError(`${file}: role '${name}' ${message}`));
-            const env = modelEnv.env;
-            const model = modelEnv.model;
+            const model = resolveRoleModel(r.model, r.harness, defaults);
             const modelChain = resolveModelChain(model, r.model_chain ?? (inheritsModelDefaults
                 ? defaults.model_chain
                 : undefined), file, name);
+            if (authProxy && harness !== 'claude-code')
+                throw new ConfigError(`${file}: role '${name}' auth_proxy is supported only by claude-code`);
+            const env = {
+                ...(defaults.env ?? {}),
+                ...(r.env ?? {}),
+                ...(authProxy ? { ANTHROPIC_BASE_URL: authProxy.base_url } : {}),
+            };
             roles.push({
                 ...r,
                 name,
@@ -281,10 +270,49 @@ export function loadConfig(configPath, options = {}) {
     const resolvedLoops = resolveLoops(baseDoc.loops, base, roles, vars);
     for (const role of roles)
         role.loops = resolvedLoops.byRole.get(role.name) ?? [];
-    return {
+    // ── Rooms, room_templates, tasks (split-config merge) ──────────────
+    // These sections may appear in the base fleet.yaml and/or in fleet.d files.
+    // Base provides defaults; fleet.d extends. Only one source may define rooms/tasks
+    // top-level (room_templates merge by name, last writer wins).
+    let rooms;
+    let ownerInviteFingerprint;
+    let ownerInvite;
+    let roomTemplates;
+    let tasks;
+    for (const { file, doc } of docs) {
+        if (doc.rooms !== undefined) {
+            if (rooms)
+                throw new ConfigError(`rooms: defined in multiple files; last: ${file}`);
+            const validated = validateRoomsConfig(deepSub(doc.rooms, vars), vars, file);
+            ownerInviteFingerprint = validated._invite?.fingerprint;
+            ownerInvite = validated._invite?.value;
+            const { _invite: _, ...clean } = validated;
+            rooms = clean;
+        }
+        if (doc.room_templates !== undefined) {
+            const validated = validateRoomTemplatesConfig(deepSub(doc.room_templates, vars), file);
+            roomTemplates = { ...(roomTemplates ?? {}), ...validated };
+        }
+        if (doc.tasks !== undefined) {
+            if (tasks)
+                throw new ConfigError(`tasks: defined in multiple files; last: ${file}`);
+            tasks = validateTasksConfig(deepSub(doc.tasks, vars), file);
+        }
+    }
+    const result = {
         roles, vars, defaults, files, startStaggerMs, diagnostics, watchdogs,
         loops: resolvedLoops.loops,
+        rooms, roomTemplates, tasks, ownerInviteFingerprint,
     };
+    if (ownerInvite !== undefined) {
+        Object.defineProperty(result, 'ownerInvite', {
+            value: ownerInvite,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+    }
+    return result;
 }
 /**
  * Canonical form of a 64-hex container ID for authorization decisions. Hex
@@ -474,16 +502,15 @@ export function resolveAuthProxy(defaults, role, file = 'config', name = 'role')
     };
 }
 export function resolveWorklogPolicy(defaults, role, file = 'config', name = 'role') {
-    if (role === false || (role === undefined && defaults === false))
+    if (defaults === undefined && role === undefined)
         return undefined;
-    if (defaults !== undefined && defaults !== false && !isPlainObject(defaults))
-        throw new ConfigError(`${file}: defaults.worklog must be a map or false`);
+    if (defaults !== undefined && !isPlainObject(defaults))
+        throw new ConfigError(`${file}: defaults.worklog must be a map`);
     if (role !== undefined && !isPlainObject(role))
-        throw new ConfigError(`${file}: role '${name}' worklog must be a map or false`);
+        throw new ConfigError(`${file}: role '${name}' worklog must be a map`);
     const merged = {
-        ...DEFAULT_WORKLOG_POLICY,
-        ...(defaults === false || defaults === undefined ? {} : defaults),
-        ...(role === undefined ? {} : role),
+        ...(defaults ?? {}),
+        ...(role ?? {}),
     };
     const bad = Object.keys(merged).filter(key => !['max_kb', 'keep_tail_kb', 'max_archives'].includes(key));
     if (bad.length)

package/dist/creation.d.ts

@@ -1,5 +1,6 @@
+import { type AttachOursClientOptions, type OursClient } from '@ours.network/sdk/client';
 import { type LockDeps } from './atomic-file.js';
-import { type FetchLike } from './monitor.js';
+import type { ResolvedRole } from './config.js';
 export type ReservationKind = 'role' | 'identity';
 export interface Reservation {
     kind: ReservationKind;
@@ -82,26 +83,30 @@ export declare function clearStaleReservations(olderThanMs?: number, now?: numbe
  * Identity provisioning (7.3). The fleet must know — before the harness starts
  * — whether the role's identity exists, and create it when it does not.
  *
- * `exists()` is answerable today: the daemon's authenticated `/identities`
- * endpoint is already used by doctor. `create()` is NOT: `ours-mcp` exposes only
- * `create-root`, and role identities are minted through the MCP `create_identity`
- * tool inside an agent session. So creation is a seam, injected by whoever can
- * satisfy it, and its absence is reported rather than papered over.
+ * `exists()` is answered through the typed SDK daemon inventory. `create()` is
+ * intentionally still a seam: fleet preserves application-owned identity
+ * creation/binding, especially the session-owned lifetime of temporary roles.
+ * Its absence is reported rather than papered over.
  */
 export interface IdentityProvisioner {
     /** Does this identity exist? `unknown` when the daemon could not be asked. */
     exists(name: string): Promise<boolean | 'unknown'>;
     /** Create it, publishing bio/persona through the same path. Absent = cannot. */
-    create?(name: string, profile: {
-        bio?: string;
-        persona?: string;
-    }): Promise<void>;
+    create?(name: string, profile: IdentityProvisionProfile): Promise<void>;
     /**
      * Undo a `create` during rollback. Only ever called for an identity THIS
      * transaction created; absent means "cannot", and the orphan is reported.
      */
     remove?(name: string): Promise<void>;
 }
+export interface IdentityProvisionProfile {
+    bio?: string;
+    persona?: string;
+    /** Permanent role identities are locally discoverable; control identities opt out. */
+    exposeLocal?: boolean;
+    /** Permanent role identities accept sibling introductions; control identities opt out. */
+    localAutoAccept?: boolean;
+}
 export type IdentityGuarantee = {
     state: 'verified';
     evidence: 'verified';
@@ -115,6 +120,8 @@ export type IdentityGuarantee = {
     evidence: 'missing' | 'unknown';
     detail: string;
 };
+/** Reconcile every permanent identity a role's supervisor owns before launch. */
+export declare function reconcilePermanentRoleIdentities(role: ResolvedRole, provisioner?: IdentityProvisioner, log?: (line: string) => void, knownRoleGuarantee?: IdentityGuarantee['state']): Promise<'verified' | 'created'>;
 /**
  * Establish the identity before the role's service is enabled.
  *
@@ -123,21 +130,29 @@ export type IdentityGuarantee = {
  * the failure a real agent hit on its first boot, having been told to bind an
  * identity that did not exist.
  */
-export declare function ensureIdentity(name: string, profile: {
-    bio?: string;
-    persona?: string;
-}, provisioner: IdentityProvisioner | undefined, log?: (line: string) => void): Promise<IdentityGuarantee>;
+export declare function ensureIdentity(name: string, profile: IdentityProvisionProfile, provisioner: IdentityProvisioner | undefined, log?: (line: string) => void): Promise<IdentityGuarantee>;
 /**
- * Ask the running ours daemon whether an identity exists, over the same
- * authenticated endpoint doctor already probes. Answers `unknown` rather than
- * guessing when the daemon cannot be reached — an unreachable daemon is not
- * evidence that the identity is missing.
+ * Ask the running ours daemon whether an identity exists through SDK 2's
+ * coherence-checking attach path. Answers `unknown` rather than guessing when
+ * the daemon cannot be reached — an unreachable daemon is not evidence that
+ * the identity is missing.
  *
- * It deliberately has no `create()`: role identities are minted through the MCP
- * `create_identity` tool, and inventing a daemon endpoint we cannot test is the
- * failure mode this release exists to stop.
+ * Permanent identities can be created before a harness starts. Creation binds
+ * the provisioning lease, so it is always released before the role or channel
+ * takes ownership. Temporary callers disable creation: a temporary identity is
+ * owned and deleted by the exact connector lease that created it, and there is
+ * no safe lease-transfer operation in the current SDK.
  */
-export declare function daemonIdentityProvisioner(env?: NodeJS.ProcessEnv, fetchImpl?: FetchLike): IdentityProvisioner;
+type IdentityInventoryClient = Pick<OursClient, 'identities'> & Partial<Pick<OursClient, 'listIdentities' | 'createIdentity' | 'setPersona' | 'releaseLease'>>;
+export interface DaemonIdentityProvisionerOptions {
+    /** False for temporary roles/watchdogs whose connector must own creation. */
+    createPermanent?: boolean;
+    /** True only for inventory checks performed by a temporary lifecycle. */
+    acceptTemporaryExisting?: boolean;
+}
+export declare function daemonIdentityProvisioner(env?: NodeJS.ProcessEnv, attachClient?: (options: AttachOursClientOptions) => Promise<IdentityInventoryClient>, options?: DaemonIdentityProvisionerOptions): IdentityProvisioner;
+/** Inventory-only variant for session-owned temporary identity lifecycles. */
+export declare function daemonIdentityInventoryProvisioner(env?: NodeJS.ProcessEnv, attachClient?: (options: AttachOursClientOptions) => Promise<IdentityInventoryClient>): IdentityProvisioner;
 /** Atomically write a role's fleet.d file, journalling it for rollback. */
 export declare function writeRoleFile(tx: CreationTransaction, file: string, contents: string): void;
 /** Where a setting's effective value came from. */
@@ -207,3 +222,4 @@ export declare function creationBuildNote(p: CreationProvenance): string | undef
 export declare function formatProvenance(p: CreationProvenance): string[];
 /** Classify one setting: an explicit CLI value, a fleet default, or built-in. */
 export declare function provenanceOf(cliValue: unknown, fleetDefault: unknown, builtIn?: unknown): ProvenanceEntry;
+export {};

package/dist/creation.js

@@ -1,8 +1,9 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { attachOursClient, } from '@ours.network/sdk/client';
 import { replaceFileAtomically, withFileLock } from './atomic-file.js';
 import { stateRoot } from './paths.js';
-import { resolveEndpoint } from './monitor.js';
 import { buildInfo, UNKNOWN_BUILD } from './provenance.js';
 /**
  * One creation transaction: role name and ours identity reserved together,
@@ -141,6 +142,37 @@ function readdirSyncSafe(dir) {
         return [];
     }
 }
+const requireGuaranteedIdentity = (role, identity, result) => {
+    if (result.state !== 'unverified')
+        return result;
+    throw new Error(`role '${role.name}': could not establish permanent ours identity '${identity}' before launch: ${result.detail}`);
+};
+/** Reconcile every permanent identity a role's supervisor owns before launch. */
+export async function reconcilePermanentRoleIdentities(role, provisioner = daemonIdentityProvisioner(), log = () => { }, knownRoleGuarantee) {
+    const roleResult = knownRoleGuarantee
+        ? {
+            state: knownRoleGuarantee,
+            evidence: knownRoleGuarantee === 'verified' ? 'verified' : 'missing',
+            detail: `identity was ${knownRoleGuarantee} by the creation transaction`,
+        }
+        : await ensureIdentity(role.identity, {
+            bio: role.bio,
+            persona: role.persona,
+            exposeLocal: true,
+            localAutoAccept: true,
+        }, provisioner, log);
+    const roleGuarantee = requireGuaranteedIdentity(role, role.identity, roleResult);
+    if (role.owner_channel) {
+        const channelIdentity = role.owner_channel.identity;
+        const channel = await ensureIdentity(channelIdentity, {
+            bio: `Authenticated owner channel for the ours-fleet ${role.name} role.`,
+            exposeLocal: false,
+            localAutoAccept: false,
+        }, provisioner, log);
+        requireGuaranteedIdentity(role, channelIdentity, channel);
+    }
+    return roleGuarantee.state;
+}
 /**
  * Establish the identity before the role's service is enabled.
  *
@@ -174,10 +206,9 @@ export async function ensureIdentity(name, profile, provisioner, log = () => { }
             detail: 'the ours daemon could not be asked',
         };
     if (!provisioner.create) {
-        // Loud, and named. The briefing will tell the agent to mint it — which is
-        // what actually happens today — but nobody is told it was "predefined".
-        log(`identity '${name}' does not exist and this host cannot create one automatically — `
-            + `the role will be told to mint it on first boot. Create it in advance to avoid that.`);
+        // Loud, and named. Permanent lifecycle callers fail closed here; temporary
+        // callers preserve connector-owned first-boot creation semantics.
+        log(`identity '${name}' does not exist and this provisioner cannot create one automatically`);
         return {
             state: 'unverified', evidence: 'missing',
             detail: 'it does not exist and cannot be created here',
@@ -189,29 +220,85 @@ export async function ensureIdentity(name, profile, provisioner, log = () => { }
         detail: 'created during spawn, with its bio and persona published',
     };
 }
-/**
- * Ask the running ours daemon whether an identity exists, over the same
- * authenticated endpoint doctor already probes. Answers `unknown` rather than
- * guessing when the daemon cannot be reached — an unreachable daemon is not
- * evidence that the identity is missing.
- *
- * It deliberately has no `create()`: role identities are minted through the MCP
- * `create_identity` tool, and inventing a daemon endpoint we cannot test is the
- * failure mode this release exists to stop.
- */
-export function daemonIdentityProvisioner(env = process.env, fetchImpl = (u, i) => globalThis.fetch(u, i)) {
-    return {
+export function daemonIdentityProvisioner(env = process.env, attachClient = attachOursClient, options = {}) {
+    const provisioner = {
         async exists(name) {
-            const ep = resolveEndpoint(env);
-            const resp = await fetchImpl(`${ep.origin}/identities`, { headers: ep.headers });
-            if (!resp.ok)
-                return 'unknown';
-            const body = await resp.json();
-            if (!Array.isArray(body.identities))
+            try {
+                const client = await attachClient({
+                    env, leaseToken: `ours-fleet-identity-preflight-${process.pid}`, clientPid: process.pid,
+                });
+                const identities = await client.identities();
+                if (!Array.isArray(identities))
+                    return 'unknown';
+                const existing = identities.find(identity => identity.name === name);
+                if (!existing)
+                    return false;
+                // A session-owned temporary identity cannot satisfy a permanent role
+                // invariant. Report it as absent so create() can reject the collision
+                // explicitly after inspecting the authoritative identity tree.
+                if (existing.temporary && options.acceptTemporaryExisting !== true)
+                    return false;
+                return true;
+            }
+            catch {
                 return 'unknown';
-            return body.identities.some(i => (typeof i === 'string' ? i : i?.name) === name);
+            }
         },
     };
+    if (options.createPermanent === false)
+        return provisioner;
+    provisioner.create = async (name, profile) => {
+        const client = await attachClient({
+            env, leaseToken: `ours-fleet-identity-create-${process.pid}-${randomUUID()}`,
+            clientPid: process.pid,
+        });
+        if (!client.listIdentities || !client.createIdentity || !client.releaseLease)
+            throw new Error('the selected ours SDK client cannot create permanent identities');
+        try {
+            const before = await client.listIdentities();
+            const existing = before.find(identity => identity.name === name);
+            if (existing) {
+                if (existing.temp)
+                    throw new Error(`identity '${name}' exists but is temporary; refusing to convert or adopt it`);
+                return; // another reconciler won the create race
+            }
+            if (!before.some(identity => identity.kind === 'root'))
+                throw new Error(`cannot create role identity '${name}': this host has no Human identity; run ours onboarding first`);
+            let createdHere = false;
+            try {
+                await client.createIdentity({
+                    name,
+                    bio: profile.bio ?? '',
+                    exposeLocal: profile.exposeLocal ?? true,
+                    localAutoAccept: profile.localAutoAccept ?? true,
+                });
+                createdHere = true;
+            }
+            catch (error) {
+                // Creation is daemon-atomic. If a concurrent reconciler won by name,
+                // accept only the compatible permanent identity now visible.
+                const after = await client.listIdentities();
+                const raced = after.find(identity => identity.name === name);
+                if (!raced || raced.temp)
+                    throw error;
+            }
+            if (createdHere && profile.persona && client.setPersona)
+                await client.setPersona({ persona: profile.persona });
+        }
+        finally {
+            // createIdentity binds this lease. The managed role/channel is the next
+            // owner, so never leave the short-lived provisioning client holding it.
+            await client.releaseLease();
+        }
+    };
+    return provisioner;
+}
+/** Inventory-only variant for session-owned temporary identity lifecycles. */
+export function daemonIdentityInventoryProvisioner(env = process.env, attachClient = attachOursClient) {
+    return daemonIdentityProvisioner(env, attachClient, {
+        createPermanent: false,
+        acceptTemporaryExisting: true,
+    });
 }
 /** Atomically write a role's fleet.d file, journalling it for rollback. */
 export function writeRoleFile(tx, file, contents) {