@ours.network/fleet 0.18.0 → 0.19.0-nightly.1

package/dist/cli.js

@@ -25,9 +25,8 @@ import { stringify } from 'yaml';
 import { resolvedRolePlan } from './resolved-plan.js';
 import { creationBuildNote, formatProvenance, readProvenance } from './creation.js';
 import { doctor } from './doctor.js';
-import { allWarnings, analyzeFleetPermissions, effectivePermissionMode, formatNative, } from './permissions.js';
+import { allWarnings, analyzeFleetPermissions, formatNative } from './permissions.js';
 import { AI_DOCS } from './docs.js';
-import { classifyActivity, describeSessionState } from './session/activity.js';
 import { controlRequest, controlSocketPath, followControl, livenessNote, } from './session/control.js';
 import { SessionControlError } from './session/types.js';
 import { readScheduledLoops, storedLoopHealth } from './loops/state.js';
@@ -36,7 +35,6 @@ import { requestWebControl } from './web/control.js';
 import { WebServiceManager } from './web/service.js';
 import { WebAccessStore, passwordAccess, validatePublicOrigin } from './web/access.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from './fleet-proxy.js';
-import { installHarnessPlugin, readHarnessPluginLock, selectedHarnessPluginIds, } from './harness-plugins.js';
 import './harness/claude-code.js'; // registers the claude-code adapter
 import './harness/codex.js'; // registers the codex adapter
 // sudo/su shells lack XDG_RUNTIME_DIR, breaking every systemctl/journalctl
@@ -67,51 +65,6 @@ const program = new Command()
     .version(VERSION);
 const cOpt = (cmd) => cmd.option('-c, --configuration <file>', 'config file (default: ~/fleet.yaml + ~/fleet.d/)');
 const collect = (value, previous) => [...previous, value];
-const pluginsCommand = program.command('plugins')
-    .description('install exact, persisted stable/nightly harness plugins');
-const changeHarnessPlugins = (update) => async (names, opts) => {
-    try {
-        const cfg = loadConfig(opts.configuration);
-        for (const harness of selectedHarnessPluginIds(names)) {
-            const channel = cfg.harnessPlugins[harness].plugin_channel;
-            const result = await installHarnessPlugin(harness, channel, { update });
-            console.log(`${harness}: ${result.lock.package}@${result.lock.version} `
-                + `(${channel}, ${result.resolved ? 'resolved and locked' : 'reused lock'})`);
-            console.log(`  lock: ${result.lockPath}`);
-            console.log(`  marketplace: ${result.marketplacePath}`);
-        }
-    }
-    catch (e) {
-        die(e);
-    }
-};
-cOpt(pluginsCommand.command('install [harnesses...]')
-    .description('install from the configured channel; reuse an existing same-channel lock'))
-    .action(changeHarnessPlugins(false));
-cOpt(pluginsCommand.command('update [harnesses...]')
-    .description('resolve configured channels once, persist exact versions, and install them'))
-    .action(changeHarnessPlugins(true));
-cOpt(pluginsCommand.command('status [harnesses...]')
-    .description('show configured channels and persisted exact versions'))
-    .action((names, opts) => {
-    try {
-        const cfg = loadConfig(opts.configuration);
-        for (const harness of selectedHarnessPluginIds(names)) {
-            const configured = cfg.harnessPlugins[harness].plugin_channel;
-            const lock = readHarnessPluginLock(harness);
-            if (!lock) {
-                console.log(`${harness}: configured=${configured}, unlocked `
-                    + `(run \`ours-fleet plugins install ${harness}\`)`);
-                continue;
-            }
-            const mismatch = lock.channel === configured ? '' : `, CONFIG MISMATCH (locked=${lock.channel})`;
-            console.log(`${harness}: configured=${configured}, ${lock.package}@${lock.version}${mismatch}`);
-        }
-    }
-    catch (e) {
-        die(e);
-    }
-});
 program.command('docs')
     .alias('man')
     .description('print the complete AI-friendly command and configuration reference')
@@ -410,14 +363,8 @@ program.command('ls').description('list running fleet sessions')
                 continue;
             try {
                 const response = await controlRequest(stateDir, { command: 'status' }, 2_000);
-                const result = response.result;
-                if (response.ok && result?.alive) {
-                    // Activity, not readiness: an idle-readiness role may be running a
-                    // steered wake turn (FLEET-002), so `ls` reports what was observed.
-                    const observed = classifyActivity(result.activity);
-                    acp.push(`${name}: acp${observed.state === 'active' ? ' (working)'
-                        : observed.state === 'quiet' ? ' (no recent agent activity)' : ''}`);
-                }
+                if (response.ok && response.result?.alive)
+                    acp.push(`${name}: acp`);
             }
             catch { /* ignore stale sockets */ }
         }
@@ -558,14 +505,6 @@ program.command('status <name>').description('unit/agent state')
     else if (ledger.consecutiveImmediateFailures > 0)
         console.log(`restarts: ${ledger.consecutiveImmediateFailures} consecutive immediate `
             + `failures, next delay ${ledger.nextDelayMs}ms (${ledger.lastReason})`);
-    // A kill the supervisor never saw leaves no other trace here. Say it out
-    // loud rather than letting the absence of a failure streak read as "fine".
-    if (ledger.lastTermination?.class === 'abrupt')
-        console.log(`last termination: ABRUPT — the previous supervisor run (started `
-            + `${ledger.lastTermination.runStartedAt ?? 'unknown'}) died without an orderly exit; `
-            + `observed ${ledger.lastTermination.observedAt}`
-            + `\n  abrupt terminations recorded: ${ledger.abruptTerminations ?? 1}`
-            + `\n  cause (signal / OOM-kill): journalctl --user -u ours-fleet-agent@${name}.service`);
     const modelStatus = joinPath(agentDir(name), '.model-status');
     if (existsSync(modelStatus)) {
         try {
@@ -584,14 +523,8 @@ program.command('status <name>').description('unit/agent state')
     if (stateDir) {
         try {
             const response = await controlRequest(stateDir, { command: 'status' }, 2_000);
-            if (response.ok) {
-                const snapshot = response.result;
+            if (response.ok)
                 console.log(`session: ${JSON.stringify(response.result)}`);
-                // `readiness` is turn occupancy, never an activity claim: a steered
-                // wake turn runs to completion with readiness pinned at `idle`
-                // (FLEET-002). Say which question each field answers.
-                console.log(describeSessionState(snapshot.readiness, snapshot.activity));
-            }
         }
         catch {
             console.log('session: acp control unavailable');
@@ -702,10 +635,7 @@ function renderLoopRows(role, state, loop) {
     return Object.entries(state.loops).filter(([name]) => !loop || name === loop).map(([name, item]) => `${role}/${name} ${item.enabled && !item.operatorDisabled ? 'enabled' : 'disabled'} `
         + `${item.activeRunId ? 'running' : 'idle'} next=${item.nextDueAt} last=${item.lastOutcome ?? 'never'} `
         + `counts=${item.counts.started}/${item.counts.completed}/${item.counts.failed} `
-        + `skip=${item.counts.skipped}(busy=${item.counts.skippedBusy},missed=${item.counts.skippedMissed})`
-        + (item.missedGap
-            ? ` gap=${item.missedGap.count}@${item.missedGap.fromAt}..${item.missedGap.throughAt}`
-            : ''));
+        + `skip=${item.counts.skipped}(busy=${item.counts.skippedBusy},missed=${item.counts.skippedMissed})`);
 }
 cOpt(loopsCommand.command('status [role] [loop]').description('show live or stored loop state'))
     .option('--json', 'emit stable JSON')
@@ -1159,7 +1089,7 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
     .option('--coordinator <name>', 'announce target')
     .option('--model <id>', 'model id to launch on (e.g. claude-fable-5); default: launcher default')
     .option('--permission-mode <mode>', 'harness permission mode (Codex: untrusted|on-request|never; Claude: native values)')
-    .option('--approval <mode>', 'fleet permission mode: ask|auto|allow (Codex ACP allow selects agent-full-access; deny is deprecated)')
+    .option('--approval <mode>', 'fleet permission mode: ask|auto|allow (deny is deprecated)')
     .option('--filesystem <mode>', 'common filesystem intent: read-only|workspace|unrestricted')
     .option('--unattended <mode>', 'permission behavior without a console: deny|wait')
     .option('--sandbox <mode>', 'Codex sandbox: read-only|workspace-write|danger-full-access')
@@ -1231,17 +1161,13 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
             console.log(`spawned ${result.lifetime} agent '${result.role}' through `
                 + `${result.caller}'s fleet proxy (state: ${result.statePath})`);
             console.log(`  ${result.harness}/${result.session}`
-                + `${result.model ? ` model=${result.model}` : ''}`
-                + (result.permissionMode
-                    ? `; permission=${result.permissionMode.fleetMode} native=${result.permissionMode.nativeMode}`
-                    : '') + '; '
+                + `${result.model ? ` model=${result.model}` : ''}; `
                 + `monitor=${result.monitor.mode} interrupt=${result.monitor.interrupt}`);
             if (result.inherited.length)
                 console.log(`  inherited omitted defaults from ${result.caller}: ${result.inherited.join(', ')}`);
             console.log(`→ watch it: ours-fleet peek ${result.role}   |   attach: ours-fleet attach ${result.role}`);
             return;
         }
-        const plannedPermissionMode = effectivePermissionMode(spawnDryRun(o).resolvedRole);
         if (o.temp) {
             const dir = await spawnTemp(o, binPath);
             console.log(`spawned temp agent '${roleName}' (state: ${dir}; gone on exit/reboot)`);
@@ -1259,8 +1185,6 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
             for (const line of formatProvenance(lastProvenance))
                 console.log(line);
         }
-        console.log(`  permission=${plannedPermissionMode.fleetMode} `
-            + `native=${plannedPermissionMode.nativeMode}`);
         console.log(`→ watch it: ours-fleet peek ${roleName}   |   attach: ours-fleet attach ${roleName}`);
     }
     catch (e) {

package/dist/config.d.ts

@@ -2,7 +2,6 @@ import { type ConfigDiagnostic, type YamlMode } from './config-yaml.js';
 import type { IsolationConfig, WrapContext } from './isolation/types.js';
 import type { ResolvedWatchdog } from './watchdog/config.js';
 import type { ResolvedLoop, ResolvedRoleLoop } from './loops/config.js';
-import { type HarnessPluginChannel, type HarnessPluginConfigs } from './harness-plugins.js';
 export interface OverseeEntry {
     role: string;
     interval: string;
@@ -12,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;
@@ -134,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;
@@ -157,8 +153,6 @@ export interface ResolvedRole extends Omit<RoleConfig, 'model' | 'owner_channel'
     worklog?: WorklogPolicy;
     auth_proxy?: AuthProxyConfig;
     loops?: ResolvedRoleLoop[];
-    /** Configured channel for a managed first-party harness plugin. */
-    harnessPluginChannel?: HarnessPluginChannel;
 }
 export interface FleetConfig {
     roles: ResolvedRole[];
@@ -171,8 +165,6 @@ export interface FleetConfig {
     diagnostics: ConfigDiagnostic[];
     watchdogs: ResolvedWatchdog[];
     loops: ResolvedLoop[];
-    /** Per-harness plugin channel intent. Exact versions live in host-local locks. */
-    harnessPlugins: HarnessPluginConfigs;
 }
 export declare class ConfigError extends Error {
 }
@@ -201,7 +193,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,18 +4,10 @@ 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 { CAPABILITIES, CAP_MONITOR_INTERRUPT_AFTER_TOOL } from './capabilities.js';
 import { runningLabel } from './provenance.js';
-import { HARNESS_PLUGIN_IDS, resolveHarnessPluginConfigs, } from './harness-plugins.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',
@@ -183,13 +175,6 @@ export function loadConfig(configPath, options = {}) {
     const vars = (baseDoc.vars ?? {});
     const defaults = (baseDoc.defaults ?? {});
     const startStaggerMs = resolveStartStaggerMs(baseDoc.start_stagger_ms, base);
-    let harnessPlugins;
-    try {
-        harnessPlugins = resolveHarnessPluginConfigs(baseDoc.harnesses, base);
-    }
-    catch (error) {
-        throw new ConfigError(error.message);
-    }
     const seen = new Map();
     const roles = [];
     for (const { file, doc } of docs) {
@@ -232,31 +217,22 @@ 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,
                 sourceFile: file,
                 harness,
-                harnessPluginChannel: HARNESS_PLUGIN_IDS.includes(harness)
-                    ? harnessPlugins[harness].plugin_channel
-                    : undefined,
                 session,
                 session_options: sessionOptions,
                 permissions,
@@ -293,7 +269,7 @@ export function loadConfig(configPath, options = {}) {
     for (const role of roles)
         role.loops = resolvedLoops.byRole.get(role.name) ?? [];
     return {
-        roles, vars, defaults, files, startStaggerMs, diagnostics, watchdogs, harnessPlugins,
+        roles, vars, defaults, files, startStaggerMs, diagnostics, watchdogs,
         loops: resolvedLoops.loops,
     };
 }
@@ -485,16 +461,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) {