@ours.network/fleet 1.1.0-nightly.1 → 1.1.0-nightly.3

package/dist/harness/claude-code-session.d.ts

@@ -3,6 +3,8 @@ import type { AcpMcpServer, SessionPrep } from './types.js';
 import type { AgentSessionAdapter, AgentSessionStartOptions, PreparedAgentSessionLaunch } from './agent-session.js';
 import { type AcpSessionTransport } from './acp-session-transport.js';
 export interface ClaudeCodeSessionStrategy {
+    resolveBrain: AgentSessionAdapter['resolveBrain'];
+    modelEnvironmentVariable: AgentSessionAdapter['modelEnvironmentVariable'];
     prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
     permissionModeId(role: ResolvedRole): string | undefined;
     mcpServers(role: ResolvedRole): AcpMcpServer[] | undefined;
@@ -13,6 +15,8 @@ export declare class ClaudeCodeAgentSessionAdapter implements AgentSessionAdapte
     private readonly strategy;
     private readonly transport;
     constructor(strategy: ClaudeCodeSessionStrategy, transport?: AcpSessionTransport);
+    resolveBrain(brain: Parameters<AgentSessionAdapter['resolveBrain']>[0]): import("./agent-session.js").ResolvedBrainSelection;
+    modelEnvironmentVariable(): string | undefined;
     prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
     start(options: AgentSessionStartOptions): Promise<import("../index.js").AgentSession>;
 }

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

@@ -8,6 +8,10 @@ export class ClaudeCodeAgentSessionAdapter {
         this.strategy = strategy;
         this.transport = transport;
     }
+    resolveBrain(brain) {
+        return this.strategy.resolveBrain(brain);
+    }
+    modelEnvironmentVariable() { return this.strategy.modelEnvironmentVariable(); }
     prepareLaunch(role, prep) {
         return this.strategy.prepareLaunch(role, prep);
     }

package/dist/harness/claude-code.js

@@ -228,6 +228,16 @@ export function makeClaudeCodeAdapter(exec = realExec, transport) {
     return {
         id: 'claude-code',
         agentSession: new ClaudeCodeAgentSessionAdapter({
+            resolveBrain(brain) {
+                if (brain.effort != null
+                    && (typeof brain.effort !== 'string' || !EFFORT_LEVELS.includes(brain.effort)))
+                    throw new Error(`Claude Code Brain effort must be one of: ${EFFORT_LEVELS.join(', ')}`);
+                return {
+                    model: brain.model,
+                    harnessOptions: { ...(brain.harnessOptions ?? {}), ...(brain.effort ? { effort: brain.effort } : {}) },
+                };
+            },
+            modelEnvironmentVariable: () => 'ANTHROPIC_MODEL',
             prepareLaunch(role, prep) {
                 const configured = role.session_options?.acp?.command;
                 const argv = Array.isArray(configured)

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

@@ -3,6 +3,8 @@ import type { AcpMcpServer, SessionPrep } from './types.js';
 import type { AgentSessionAdapter, AgentSessionStartOptions, PreparedAgentSessionLaunch } from './agent-session.js';
 import { type AcpSessionTransport } from './acp-session-transport.js';
 export interface CodexSessionStrategy {
+    resolveBrain: AgentSessionAdapter['resolveBrain'];
+    modelEnvironmentVariable: AgentSessionAdapter['modelEnvironmentVariable'];
     prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
     permissionModeId(role: ResolvedRole): string | undefined;
     mcpServers(role: ResolvedRole): AcpMcpServer[] | undefined;
@@ -13,6 +15,8 @@ export declare class CodexAgentSessionAdapter implements AgentSessionAdapter {
     private readonly strategy;
     private readonly transport;
     constructor(strategy: CodexSessionStrategy, transport?: AcpSessionTransport);
+    resolveBrain(brain: Parameters<AgentSessionAdapter['resolveBrain']>[0]): import("./agent-session.js").ResolvedBrainSelection;
+    modelEnvironmentVariable(): string | undefined;
     prepareLaunch(role: ResolvedRole, prep: SessionPrep): PreparedAgentSessionLaunch;
     start(options: AgentSessionStartOptions): Promise<import("../index.js").AgentSession>;
 }

package/dist/harness/codex-session.js

@@ -8,6 +8,10 @@ export class CodexAgentSessionAdapter {
         this.strategy = strategy;
         this.transport = transport;
     }
+    resolveBrain(brain) {
+        return this.strategy.resolveBrain(brain);
+    }
+    modelEnvironmentVariable() { return this.strategy.modelEnvironmentVariable(); }
     prepareLaunch(role, prep) {
         return this.strategy.prepareLaunch(role, prep);
     }

package/dist/harness/codex.js

@@ -251,6 +251,20 @@ export function makeCodexAdapter(exec = realExec, transport) {
     return {
         id: 'codex',
         agentSession: new CodexAgentSessionAdapter({
+            resolveBrain(brain) {
+                const levels = ['low', 'medium', 'high', 'xhigh', 'max', 'ultra'];
+                if (brain.effort != null
+                    && (typeof brain.effort !== 'string' || !levels.includes(brain.effort)))
+                    throw new Error(`Codex Brain effort must be one of: ${levels.join(', ')}`);
+                const harnessOptions = { ...(brain.harnessOptions ?? {}) };
+                if (brain.effort)
+                    harnessOptions.config = {
+                        ...(harnessOptions.config ?? {}),
+                        model_reasoning_effort: brain.effort,
+                    };
+                return { model: brain.model, harnessOptions };
+            },
+            modelEnvironmentVariable: () => undefined,
             prepareLaunch(role, prep) {
                 const launch = codexAgentLaunch(role, prep);
                 const { permissionMetadataSource, ...neutral } = launch;

package/dist/harness/registry.js

@@ -1,5 +1,9 @@
 const adapters = new Map();
 export function registerAdapter(a) {
+    if (typeof a.agentSession?.resolveBrain !== 'function')
+        throw new Error(`harness adapter '${a.id}' must implement agentSession.resolveBrain(): translate neutral model/effort`);
+    if (typeof a.agentSession?.modelEnvironmentVariable !== 'function')
+        throw new Error(`harness adapter '${a.id}' must implement agentSession.modelEnvironmentVariable()`);
     // Enforced here rather than left to the type system: an adapter that silently
     // omits the capability is how the neutral-permission warnings ended up with no
     // caller and no reader.

package/dist/index.d.ts

@@ -13,7 +13,7 @@ export { effectivePermissionMode } from './permissions.js';
 export { pickBackend } from './supervisor/index.js';
 export type { SupervisorBackend } from './supervisor/types.js';
 export { up, down, restartRoles, rmRole, applyRole } from './ops.js';
-export { spawnPermanent, spawnTemp, buildRoleConfig, profileValues, validateSpawnOpts, } from './spawn.js';
+export { spawnPermanent, spawnTemp, agentDefinitionFromSpawn, validateSpawnOpts, } from './spawn.js';
 export { RoleRepository } from './application/role-repository.js';
 export { FleetQueryService } from './application/fleet-query-service.js';
 export { AcpRoleSessionAdapter } from './application/session-control.js';

package/dist/index.js

@@ -9,7 +9,7 @@ export { generateBriefing } from './briefing.js';
 export { effectivePermissionMode } from './permissions.js';
 export { pickBackend } from './supervisor/index.js';
 export { up, down, restartRoles, rmRole, applyRole } from './ops.js';
-export { spawnPermanent, spawnTemp, buildRoleConfig, profileValues, validateSpawnOpts, } from './spawn.js';
+export { spawnPermanent, spawnTemp, agentDefinitionFromSpawn, validateSpawnOpts, } from './spawn.js';
 export { RoleRepository } from './application/role-repository.js';
 export { FleetQueryService } from './application/fleet-query-service.js';
 export { AcpRoleSessionAdapter } from './application/session-control.js';

package/dist/init-guidance.d.ts

@@ -0,0 +1 @@
+export declare const INIT_COMPLETION_GUIDANCE = "\nNext:\n  cp \"$(npm root -g)/@ours.network/fleet/examples/fleet.yaml\" ~/fleet.yaml\n  cp -R \"$(npm root -g)/@ours.network/fleet/examples/fleet\" ~/fleet\n  edit ~/fleet.yaml and ~/fleet/{agents,roles,brains}/*.yaml, then: ours-fleet up";

package/dist/init-guidance.js

@@ -0,0 +1,5 @@
+export const INIT_COMPLETION_GUIDANCE = `
+Next:
+  cp "$(npm root -g)/@ours.network/fleet/examples/fleet.yaml" ~/fleet.yaml
+  cp -R "$(npm root -g)/@ours.network/fleet/examples/fleet" ~/fleet
+  edit ~/fleet.yaml and ~/fleet/{agents,roles,brains}/*.yaml, then: ours-fleet up`;

package/dist/model-env.d.ts

@@ -10,14 +10,13 @@ import type { ResolvedRole } from './config.js';
  * ACP role, and a fleet-wide `defaults.env.ANTHROPIC_MODEL` silently outranked
  * an explicitly requested one.
  */
-export declare const MODEL_ENV_BY_HARNESS: Readonly<Record<string, string>>;
 /** The model-pin variable for a harness, or undefined if it pins no model by env. */
 export declare function modelEnvVar(harness: string | undefined): string | undefined;
 export interface RoleModelEnvInput {
     harness: string;
     /** Already resolved by `resolveRoleModel` — may come from the fleet default. */
     model: string | undefined;
-    /** True when the role (or `--model`) named a model, including `model: null`. */
+    /** True when the resolved Brain named a model, including `model: null`. */
     modelWasExplicit: boolean;
     defaultsEnv?: Record<string, string>;
     roleEnv?: Record<string, string>;
@@ -36,7 +35,7 @@ export interface RoleModelEnv {
  * never disagree.
  *
  * Precedence, highest first:
- *   1. an explicit `model:` / `--model` on the role
+ *   1. an explicit `model:` on the resolved Brain
  *   2. the role's own `env:` pin
  *   3. the fleet `defaults.model`
  *   4. the fleet `defaults.env` pin

package/dist/model-env.js

@@ -1,3 +1,4 @@
+import { getAdapter } from './harness/registry.js';
 /**
  * Which environment variable a harness reads to pin the model it RUNS.
  *
@@ -9,19 +10,16 @@
  * ACP role, and a fleet-wide `defaults.env.ANTHROPIC_MODEL` silently outranked
  * an explicitly requested one.
  */
-export const MODEL_ENV_BY_HARNESS = {
-    'claude-code': 'ANTHROPIC_MODEL',
-};
 /** The model-pin variable for a harness, or undefined if it pins no model by env. */
 export function modelEnvVar(harness) {
-    return harness === undefined ? undefined : MODEL_ENV_BY_HARNESS[harness];
+    return harness === undefined ? undefined : getAdapter(harness).agentSession.modelEnvironmentVariable();
 }
 /**
  * Resolve a role's environment and its runtime model TOGETHER, so the two can
  * never disagree.
  *
  * Precedence, highest first:
- *   1. an explicit `model:` / `--model` on the role
+ *   1. an explicit `model:` on the resolved Brain
  *   2. the role's own `env:` pin
  *   3. the fleet `defaults.model`
  *   4. the fleet `defaults.env` pin

package/dist/ops.js

@@ -1,7 +1,7 @@
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, unlinkSync, } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID, createHash } from 'node:crypto';
-import { agentDir, fleetDDir, watchdogsRoot } from './paths.js';
+import { agentDir, watchdogsRoot } from './paths.js';
 import { findRole } from './config.js';
 import { getAdapter } from './harness/registry.js';
 import { generateBriefing } from './briefing.js';
@@ -9,6 +9,7 @@ import { resetRestartLedger } from './runner.js';
 import { archiveTempState, stopTempSupervisor, tempSupervisorLiveness, } from './temp-lifecycle.js';
 import { realExec } from './exec.js';
 import { daemonIdentityProvisioner, reconcilePermanentRoleIdentities, } from './creation.js';
+import { provesGeneratedAgentSource } from './generated-agent-source.js';
 // Launch staggering now lives at the harness-launch point (the runner's start
 // gate, driven by `start_stagger_ms`), so it covers systemd host-boot too — not
 // just the `up`/`restart` command loop below. The old in-loop FLEET_START_STAGGER
@@ -264,9 +265,10 @@ export async function rmRole(cfg, name, deps) {
         return;
     }
     const role = findRole(cfg, name);
+    const generatedSource = provesGeneratedAgentSource(agentDir(name), cfg.files[0], role.sourceFile);
     await deps.backend.uninstall(name);
     rmSync(agentDir(name), { recursive: true, force: true });
-    if (role.sourceFile.startsWith(fleetDDir() + '/')) {
+    if (generatedSource && existsSync(role.sourceFile)) {
         unlinkSync(role.sourceFile);
         deps.log(`removed ${role.sourceFile}`);
     }

package/dist/owner-channel/commands.js

@@ -630,7 +630,8 @@ export const ownerCommands = [
                     ...(t.builtin ? ['Source: built-in'] : []),
                     ...(t.contract ? [`Contract: ${t.contract}`] : []),
                     'Members:',
-                    ...t.members.map(m => `  ${m.slot} (${m.role}) ×${m.count} → role_ref: ${m.role_ref}`),
+                    ...t.members.map(m => `  ${m.slot} (${m.role}) ×${m.count} → `
+                        + `${'ref' in m.agent ? `Agent ref: ${m.agent.ref}` : 'inline Agent'}`),
                 ];
                 await ctx.reply(lines.join('\n'));
             };

package/dist/resolved-plan.d.ts

@@ -1,5 +1,6 @@
 import type { FleetConfig, ResolvedRole } from './config.js';
-export declare const RESOLVED_PLAN_SCHEMA_VERSION = 1;
+export declare const RESOLVED_PLAN_SCHEMA_VERSION = 2;
+export declare const redactSensitive: (value: unknown, key?: string) => unknown;
 /** Stable, secret-safe machine contract consumed by config JSON and spawn dry-run. */
 export declare function resolvedPlan(cfg: FleetConfig): Record<string, unknown>;
-export declare function resolvedRolePlan(role: ResolvedRole): Record<string, unknown>;
+export declare function resolvedRolePlan(role: ResolvedRole, manifestDir?: string): Record<string, unknown>;

package/dist/resolved-plan.js

@@ -1,8 +1,10 @@
 import { analyzeRolePermissions } from './permissions.js';
-export const RESOLVED_PLAN_SCHEMA_VERSION = 1;
+import { dirname, relative } from 'node:path';
+import { isSensitiveConfigKey } from './sensitive-config.js';
+export const RESOLVED_PLAN_SCHEMA_VERSION = 2;
 const sortedObject = (value) => Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
-const redactSensitive = (value, key = '') => {
-    if (/(?:secret|token|password|authorization|api[_-]?key)/i.test(key))
+export const redactSensitive = (value, key = '') => {
+    if (isSensitiveConfigKey(key))
         return '<redacted>';
     if (Array.isArray(value))
         return value.map(item => redactSensitive(item));
@@ -14,12 +16,17 @@ const redactSensitive = (value, key = '') => {
 };
 /** Stable, secret-safe machine contract consumed by config JSON and spawn dry-run. */
 export function resolvedPlan(cfg) {
+    const manifestDir = dirname(cfg.files[0] ?? '.');
     return {
         schemaVersion: RESOLVED_PLAN_SCHEMA_VERSION,
+        configMode: cfg.configMode ?? 'split-v2',
         sourceFiles: [...cfg.files],
+        sourceDocuments: (cfg.sourceDocuments ?? []).map(document => ({
+            ...document, path: relative(manifestDir, document.path) || document.path,
+        })),
         startStaggerMs: cfg.startStaggerMs,
         diagnostics: cfg.diagnostics.map(diagnostic => ({ ...diagnostic })),
-        roles: cfg.roles.map(resolvedRolePlan),
+        roles: cfg.roles.map(role => resolvedRolePlan(role, manifestDir)),
         loops: cfg.loops.map(loop => sortedObject({
             name: loop.name, selectors: [...loop.selectors], roles: [...loop.roleNames],
             intervalMs: loop.intervalMs, initialDelayMs: loop.initialDelayMs, jitterMs: loop.jitterMs,
@@ -36,16 +43,25 @@ export function resolvedPlan(cfg) {
         })),
     };
 }
-export function resolvedRolePlan(role) {
+export function resolvedRolePlan(role, manifestDir = dirname(role.sourceFile)) {
     const analysis = analyzeRolePermissions(role);
     return {
         name: role.name,
         sourceFile: role.sourceFile,
+        references: Object.values(role.provenance ?? {}).flatMap(item => item.viaReference ? [item.viaReference] : [])
+            .filter((item, index, all) => all.findIndex(other => JSON.stringify(other) === JSON.stringify(item)) === index)
+            .sort((a, b) => a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id)
+            || a.sourcePointer.localeCompare(b.sourcePointer)),
+        provenance: sortedObject(Object.fromEntries(Object.entries(role.provenance ?? {}).map(([field, item]) => [
+            field, { ...item, sourceFile: item.sourceKind === 'built-in'
+                    ? item.sourceFile : relative(manifestDir, item.sourceFile) || item.sourceFile },
+        ]))),
         identity: role.identity,
         harness: role.harness,
         session: role.session,
         sessionOptions: role.session_options ?? null,
         model: role.model ?? null,
+        effort: role.effort ?? null,
         modelChain: role.model_chain ?? null,
         cwd: role.cwd ?? null,
         coordinator: role.coordinator ?? null,

package/dist/rooms-tasks/cli.js

@@ -409,7 +409,8 @@ export function registerTemplateCommands(parent, cOpt) {
                 console.log(`\nContract:\n${t.contract}`);
             console.log(`\nMembers:`);
             for (const m of t.members)
-                console.log(`  ${m.slot}: ${m.count}× ${m.role} (ref: ${m.role_ref})`);
+                console.log(`  ${m.slot}: ${m.count}× ${m.role} (`
+                    + `${'ref' in m.agent ? `agent ref: ${m.agent.ref}` : 'inline Agent'})`);
             console.log(`\nContent hash: ${t.content_hash}`);
         }
         catch (e) {

package/dist/rooms-tasks/config.js

@@ -1,7 +1,8 @@
 import { existsSync, readFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
-import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, TEMPLATE_OVERRIDE_KEYS as TOK, } from './types.js';
+import { ROOMS_KEYS as RK, ROOMS_OWNER_KEYS as ROK, ROOMS_COWORK_KEYS as RCK, ROOMS_DEFAULTS_KEYS as RDK, TASKS_KEYS as TK, TEMPLATE_KEYS as TPK, TEMPLATE_MEMBER_KEYS as TMK, } from './types.js';
 import { BUILTIN_TEMPLATES } from './templates.js';
+import { isSensitiveConfigKey } from '../sensitive-config.js';
 const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
 const CID_RE = /^[0-9a-fA-F]{64}$/;
 export class RoomsTasksConfigError extends Error {
@@ -136,19 +137,33 @@ export function validateRoomTemplatesConfig(raw, path) {
                 throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].role: required string`);
             if (!Number.isInteger(m.count) || m.count < 1)
                 throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].count: required positive integer`);
-            if (!m.role_ref || typeof m.role_ref !== 'string')
-                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].role_ref: required string`);
-            if (m.overrides !== undefined) {
-                if (!isPlainObject(m.overrides))
-                    throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].overrides: must be a mapping`);
-                rejectUnknown(m.overrides, TOK, path, `room_templates.${name}.members[${i}].overrides`);
+            if (!isPlainObject(m.agent))
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: required mapping`);
+            const agentKeys = Object.keys(m.agent);
+            const isRef = agentKeys.length === 1 && typeof m.agent.ref === 'string';
+            const isDefinition = agentKeys.includes('role') && agentKeys.includes('brain');
+            if (!isRef && !isDefinition)
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: must be {ref} or canonical {role, brain, ...}`);
+            const containsSensitive = (value) => Array.isArray(value)
+                ? value.some(containsSensitive)
+                : Boolean(value && typeof value === 'object' && Object.entries(value)
+                    .some(([key, child]) => isSensitiveConfigKey(key) || containsSensitive(child)));
+            if (isDefinition && containsSensitive(m.agent))
+                throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: inline sensitive configuration cannot be persisted; use references`);
+            if (isDefinition) {
+                const definition = m.agent;
+                const brain = isPlainObject(definition.brain) && isPlainObject(definition.brain.inline)
+                    ? definition.brain.inline : undefined;
+                if (definition.env !== undefined || definition.owner_channel !== undefined
+                    || definition.auth_proxy !== undefined || brain?.harness_options !== undefined
+                    || brain?.session_options !== undefined)
+                    throw new RoomsTasksConfigError(path, `room_templates.${name}.members[${i}].agent: secret-capable inline fields cannot be persisted; use references`);
             }
             return {
                 slot: m.slot,
                 role: m.role,
                 count: m.count,
-                role_ref: m.role_ref,
-                overrides: m.overrides,
+                agent: structuredClone(m.agent),
             };
         });
         let room;

package/dist/rooms-tasks/provision.js

@@ -1,10 +1,10 @@
-import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
 import { parse } from 'yaml';
 import { advanceSaga, setSagaError, updateMemberSeats, updateMemberStartup, activateRoom, getRoomRecord, } from './room-state.js';
 import { activateTask, updateTaskMembers, blockTask, unblockTask, getTask, } from './task-state.js';
 import { spawnTemp } from '../spawn.js';
-import { findRole } from '../config.js';
+import { findRole, loadConfig } from '../config.js';
 import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, } from '../fleet-proxy.js';
 import { controlRequest } from '../session/control.js';
 import { SessionControlError } from '../session/types.js';
@@ -21,6 +21,26 @@ export function getBinPath() {
         return process.argv[1];
     }
 }
+function canonicalJson(value) {
+    if (Array.isArray(value))
+        return `[${value.map(canonicalJson).join(',')}]`;
+    if (value && typeof value === 'object')
+        return `{${Object.entries(value)
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson(item)}`).join(',')}}`;
+    return JSON.stringify(value);
+}
+function launchDefinition(definition) {
+    const selectionEvidence = (selection) => 'ref' in selection ? { kind: 'ref', id: selection.ref } : { kind: 'inline' };
+    return {
+        projection: {
+            brain: selectionEvidence(definition.brain), role: selectionEvidence(definition.role),
+            operationalFields: Object.keys(definition)
+                .filter(key => key !== 'brain' && key !== 'role').sort(),
+        },
+        fingerprint: createHash('sha256').update(canonicalJson(definition)).digest('hex'),
+    };
+}
 async function spawnRoomMember(options, binPath) {
     const stateDir = process.env[FLEET_PROXY_STATE_DIR_ENV];
     if (!stateDir)
@@ -52,28 +72,31 @@ function expandMembers(template, prefix) {
                 name: `${prefix}-${slot.slot}-${i}`,
                 slot: slot.slot,
                 coworkRole: slot.role,
-                roleRef: slot.role_ref,
-                overrides: slot.overrides,
+                agent: structuredClone(slot.agent),
             });
         }
     }
     return result;
 }
 function settingsFor(member, cfg) {
-    let refRole;
-    try {
-        refRole = findRole(cfg, member.roleRef);
+    if (!('ref' in member.agent)) {
+        const role = member.agent.role;
+        if (cfg.files[0] && existsSync(cfg.files[0]) && statSync(cfg.files[0]).isFile())
+            loadConfig(cfg.files[0], { additionalAgent: {
+                    id: `RoomPreflight${member.name.replace(/[^A-Za-z0-9_-]/g, '')}`.slice(0, 64),
+                    definition: member.agent,
+                } });
+        return { definition: structuredClone(member.agent),
+            ...('inline' in role && typeof role.inline.persona === 'string'
+                ? { persona: role.inline.persona } : {}) };
     }
-    catch { /* no ref role */ }
-    const permissions = member.overrides?.permissions;
+    const refRole = findRole(cfg, member.agent.ref);
+    const definition = cfg.agentDefinitions?.[member.agent.ref];
+    if (!definition)
+        throw new Error(`Agent '${member.agent.ref}' has no canonical definition`);
     return {
-        model: member.overrides?.model ?? refRole?.model,
-        harness: member.overrides?.harness ?? refRole?.harness,
-        cwd: member.overrides?.cwd ?? refRole?.cwd,
-        persona: member.overrides?.persona ?? refRole?.persona,
-        approval: permissions?.approval,
-        filesystem: permissions?.filesystem,
-        unattended: permissions?.unattended,
+        definition: structuredClone(definition),
+        persona: refRole.persona,
     };
 }
 function roomTask(input, member, settings, members, roomIdentityCid, ownerSeatCid) {
@@ -104,13 +127,11 @@ function launchMatches(dir, member, actionId, taskSha, roomId, roomIdentityCid,
         const role = parse(readFileSync(`${dir}/role.yaml`, 'utf8'));
         const startup = role.roomMemberStartup;
         return role.identity === member.name
-            && typeof role.mission === 'string'
-            && sha256Text(role.mission) === taskSha
             && startup?.room_id === roomId
             && startup.room_identity_cid === roomIdentityCid
             && startup.identity_name === member.name
             && startup.role === member.coworkRole
-            && startup.task === role.mission
+            && sha256Text(startup.task ?? '') === taskSha
             && (expectedInviteId === undefined || startup.invite_id === expectedInviteId)
             && typeof startup.invite === 'string'
             && startup.invite.length > 0;
@@ -199,10 +220,13 @@ async function launchMember(input) {
     let effectiveActionId = actionId;
     const attempt = (seat.launch?.attempt ?? 0) + 1;
     const taskSha = sha256Text(startup.task);
+    const effectiveAgentDefinition = structuredClone(settings.definition);
+    const { projection: agentDefinition, fingerprint: agentFingerprint } = launchDefinition(effectiveAgentDefinition);
     const proxyCaller = process.env[FLEET_PROXY_STATE_DIR_ENV]
         ? process.env[FLEET_PROXY_CALLER_ENV] : undefined;
     updateMemberStartup(provision.roomId, member.name, { launch: {
             state: 'intent', attempt, action_id: actionId, mission_sha256: taskSha,
+            agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
             ...(proxyCaller ? { caller_role: proxyCaller } : {}),
             updated_at: new Date().toISOString(),
         } });
@@ -211,13 +235,7 @@ async function launchMember(input) {
             name: member.name,
             temp: true,
             identity: member.name,
-            mission: startup.task,
-            model: settings.model,
-            harness: settings.harness,
-            cwd: settings.cwd,
-            approval: settings.approval,
-            filesystem: settings.filesystem,
-            unattended: settings.unattended,
+            agentDefinition: settings.definition,
             surface: 'agent',
             creationActionId: actionId,
             roomMemberStartup: startup,
@@ -227,7 +245,8 @@ async function launchMember(input) {
         if (launched.creationActionId !== actionId) {
             updateMemberStartup(provision.roomId, member.name, { launch: {
                     state: 'intent', attempt, action_id: launched.creationActionId,
-                    mission_sha256: taskSha, updated_at: new Date().toISOString(),
+                    mission_sha256: taskSha, agent_definition: agentDefinition,
+                    agent_fingerprint: agentFingerprint, updated_at: new Date().toISOString(),
                     ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
                 } });
         }
@@ -237,6 +256,7 @@ async function launchMember(input) {
         }
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'launched', attempt, action_id: launched.creationActionId, mission_sha256: taskSha,
+                agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
                 ...(launched.callerRole ? { caller_role: launched.callerRole } : {}),
                 launch_id: supervisor.launchId, updated_at: new Date().toISOString(),
             } });
@@ -244,6 +264,7 @@ async function launchMember(input) {
     catch (error) {
         updateMemberStartup(provision.roomId, member.name, { launch: {
                 state: 'failed', attempt, action_id: effectiveActionId, mission_sha256: taskSha,
+                agent_definition: agentDefinition, agent_fingerprint: agentFingerprint,
                 ...(proxyCaller ? { caller_role: proxyCaller } : {}),
                 updated_at: new Date().toISOString(),
                 error: error instanceof Error ? error.message : String(error),
@@ -289,6 +310,8 @@ export async function provisionMembers(input) {
     const { cfg, cowork, roomId, taskId, template } = input;
     const prefix = taskId ? shortId(taskId) : `room-${shortId(roomId)}`;
     const members = expandMembers(template, prefix);
+    // Resolve every Agent before persisting launch intent or touching Cowork membership.
+    const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg)]));
     const existing = getRoomRecord(roomId);
     if (!existing?.room_identity_cid)
         throw new Error(`room ${roomId} has no pinned room identity CID`);
@@ -299,15 +322,27 @@ export async function provisionMembers(input) {
         && members.every(member => persistedNames.has(member.name));
     if (!resuming) {
         advanceSaga(roomId, 'create_members', 3);
-        updateMemberSeats(roomId, members.map(member => ({
-            role_name: member.name,
-            slot: member.slot,
-            cowork_role: member.coworkRole,
-            seat_state: 'pending',
-            launch: { state: 'pending', attempt: 0, updated_at: new Date().toISOString() },
-        })));
+        updateMemberSeats(roomId, members.map(member => {
+            const evidence = launchDefinition(settings.get(member.name).definition);
+            return ({
+                role_name: member.name,
+                slot: member.slot,
+                cowork_role: member.coworkRole,
+                seat_state: 'pending',
+                launch: { state: 'pending', attempt: 0,
+                    agent_definition: evidence.projection, agent_fingerprint: evidence.fingerprint,
+                    updated_at: new Date().toISOString() },
+            });
+        }));
+    }
+    else {
+        for (const member of members) {
+            const seat = existing.member_seats.find(candidate => candidate.role_name === member.name);
+            const evidence = launchDefinition(settings.get(member.name).definition);
+            if (!seat.launch?.agent_fingerprint || seat.launch.agent_fingerprint !== evidence.fingerprint)
+                throw new Error(`Agent definition drift for ${member.name}; durable launch intent does not match current configuration`);
+        }
     }
-    const settings = new Map(members.map(member => [member.name, settingsFor(member, cfg)]));
     const tasks = new Map(members.map(member => [member.name, roomTask(input, member, settings.get(member.name), members, roomIdentityCid, ownerSeatCid)]));
     const policy = {
         timeoutMs: input.startupWait?.timeoutMs ?? 60_000,

package/dist/rooms-tasks/templates.js

@@ -12,9 +12,9 @@ const TEAM = {
         'Completion requires tester sign-off.',
     ].join('\n'),
     members: [
-        { slot: 'architect', role: 'Architect', count: 1, role_ref: 'Architect' },
-        { slot: 'developer', role: 'Developer', count: 1, role_ref: 'Developer' },
-        { slot: 'tester', role: 'Tester', count: 1, role_ref: 'Tester' },
+        { slot: 'architect', role: 'Architect', count: 1, agent: { ref: 'Architect' } },
+        { slot: 'developer', role: 'Developer', count: 1, agent: { ref: 'Developer' } },
+        { slot: 'tester', role: 'Tester', count: 1, agent: { ref: 'Tester' } },
     ],
 };
 const PAIR = {
@@ -30,8 +30,8 @@ const PAIR = {
         'Completion requires joint sign-off.',
     ].join('\n'),
     members: [
-        { slot: 'secretary', role: 'Secretary', count: 1, role_ref: 'Secretary' },
-        { slot: 'critic', role: 'Critic', count: 1, role_ref: 'Critic' },
+        { slot: 'secretary', role: 'Secretary', count: 1, agent: { ref: 'Secretary' } },
+        { slot: 'critic', role: 'Critic', count: 1, agent: { ref: 'Critic' } },
     ],
 };
 const SINGLE = {
@@ -45,7 +45,7 @@ const SINGLE = {
         'Owner reviews and approves completion.',
     ].join('\n'),
     members: [
-        { slot: 'agent', role: 'Agent', count: 1, role_ref: 'Agent' },
+        { slot: 'agent', role: 'Agent', count: 1, agent: { ref: 'Agent' } },
     ],
 };
 export const BUILTIN_TEMPLATES = [TEAM, PAIR, SINGLE];