@pikku/core 0.12.141 → 0.12.142

package/dist/wirings/virtual-user/virtual-user-run-store.d.ts

@@ -16,7 +16,7 @@ import type { IntentRecord, StepRecord, VirtualUserDisposition, VirtualUserFindi
  */
 export interface VirtualUserRunRecord {
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     /** What makes a run replayable at all — a finding without it is an anecdote. */
     seed: number;
@@ -59,7 +59,7 @@ export interface VirtualUserRunRecord {
 }
 /** What a run is created with — everything else is filled in by the outcome. */
 export interface VirtualUserRunStart {
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     seed: number;
     goals?: readonly string[];
@@ -101,9 +101,9 @@ export interface VirtualUserRunStore {
     /** Marks a run `failed`. The run itself broke; it has no findings. */
     fail(runId: string, error: string): Promise<void>;
     get(runId: string): Promise<VirtualUserRunRecord | null>;
-    /** Newest first. `persona` narrows to one persona's history. */
+    /** Newest first. `virtualUserId` narrows to one virtual user's history. */
     list(options?: {
-        persona?: string;
+        virtualUserId?: string;
         limit?: number;
         offset?: number;
     }): Promise<VirtualUserRunRecord[]>;

package/dist/wirings/virtual-user/virtual-user-scaffold.d.ts

@@ -1,10 +1,11 @@
+import { type InProcessAuth } from '../../services/virtual-user-sign-in.js';
 import type { Logger } from '../../services/logger.js';
 import type { MetaService } from '../../services/meta-service.js';
 import type { VariablesService } from '../../services/variables-service.js';
 import type { AgentRunnerService } from '../../services/agent-runner-service.js';
-import type { HttpPersonasConfig } from '../../services/http-personas.js';
-import type { ResolvedPersona, ScenarioPersonas } from '../../services/personas-service.js';
-import type { PersonaEnvironment } from '../persona/persona-environments.js';
+import type { HttpVirtualUsersConfig } from '../../services/http-virtual-users.js';
+import type { ResolvedVirtualUser, ScenarioVirtualUsers } from '../../services/virtual-users-service.js';
+import type { VirtualUserEnvironment } from '../virtual-user/virtual-user-environments.js';
 import type { StepRecord, VirtualUserDisposition } from './virtual-user.types.js';
 import type { VirtualUserRunRecord, VirtualUserRunStore } from './virtual-user-run-store.js';
 import type { VirtualUserScheduleRecord, VirtualUserScheduleStore } from './virtual-user-schedule-store.js';
@@ -20,11 +21,11 @@ import type { VirtualUserTickResult } from './virtual-user-schedule.js';
  * once rather than in every generated copy of it.
  *
  * What an application does supply arrives as a parameter — its declared
- * personas, its `createPersonas`, its config — because those are the only
+ * virtual users, its `createVirtualUsers`, its config — because those are the only
  * things codegen knows that this cannot.
  */
-/** Persona id → the declaration, which is what `personaConfigs` is. */
-export type ScaffoldPersonas = Record<string, ResolvedPersona>;
+/** Virtual user id → the declaration, which is what `virtualUserConfigs` is. */
+export type ScaffoldVirtualUsers = Record<string, ResolvedVirtualUser>;
 /**
  * The variables a scaffolded run reads.
  *
@@ -39,48 +40,27 @@ export declare const VIRTUAL_USER_VARIABLES: {
      * somewhere it only assumed was itself.
      */
     readonly apiUrl: 'VIRTUAL_USER_API_URL';
-    readonly secret: 'SCENARIO_ACTOR_SECRET';
     readonly model: 'VIRTUAL_USER_MODEL';
     /**
-     * The same two variables a scenario run reads, because a virtual user signs
-     * in and calls through exactly the doors a scenario does. An app that mounts
-     * auth somewhere other than the root — `/api/auth` is the common one — has no
-     * other way to say so, and without them the run signs in against a 404 and
-     * spends its whole budget thinking about why nothing works.
+     * Where the app serves its exposed RPCs, as a scenario run reads it. An app
+     * that mounts them somewhere other than `/rpc` has no other way to say so.
      */
-    readonly signInPath: 'SCENARIO_SIGN_IN_PATH';
     readonly rpcPath: 'SCENARIO_RPC_PATH';
-    /**
-     * The deployed way in. A Fabric operator token is asymmetric — a stage can
-     * verify one and can never mint one — so unlike the actor secret it is safe
-     * for a run against a real environment. Read from the environment only as the
-     * fallback for a run nobody handed a token to, which is what a schedule is.
-     */
-    readonly operatorToken: 'FABRIC_OPERATOR_TOKEN';
 };
 /**
- * Which door under the auth mount, given the credential in hand.
- *
- * Both are better-auth plugins mounted side by side, so `SCENARIO_SIGN_IN_PATH`
- * names the mount and the last segment is ours to pick — an app that moved auth
- * to `/api/auth` says so once and both paths follow. A path that names neither
- * plugin is left alone, since it was configured deliberately.
- */
-export declare const signInPathFor: (configured: string | undefined, plugin: 'actor' | 'fabric') => string | undefined;
-/**
- * The declared persona behind an id, refused unless it is one a run may be.
+ * The declared virtual user behind an id, refused unless it is one a run may be.
  *
- * An acted-upon persona has no session of its own, and running one would race
+ * An acted-upon virtual user has no session of its own, and running one would race
  * whatever scenario acts on it.
  */
-export declare const runnablePersona: (personas: ScaffoldPersonas, personaId: string) => ResolvedPersona;
+export declare const runnableVirtualUser: (virtualUsers: ScaffoldVirtualUsers, virtualUserId: string) => ResolvedVirtualUser;
 /** The store, or the error naming the one to wire. */
 export declare const requireVirtualUserRunStore: (store: VirtualUserRunStore | undefined, reading?: boolean) => VirtualUserRunStore;
 export declare const requireVirtualUserScheduleStore: (store: VirtualUserScheduleStore | undefined) => VirtualUserScheduleStore;
 /** What a caller asked for, before the declaration fills in what it left out. */
 export interface StartVirtualUserRunParams {
     store: VirtualUserRunStore | undefined;
-    personas: ScaffoldPersonas;
+    virtualUsers: ScaffoldVirtualUsers;
     /**
      * The app's config, read only for `nodeEnv` — structural because an
      * application's Config is its own interface and need not declare it at all.
@@ -89,11 +69,11 @@ export interface StartVirtualUserRunParams {
     config: {
         nodeEnv?: string;
     } | undefined;
-    /** `environments` from pikku.config.json, as generated beside the personas. */
-    environments?: Readonly<Record<string, PersonaEnvironment>>;
+    /** `environments` from pikku.config.json, as generated beside the virtual users. */
+    environments?: Readonly<Record<string, VirtualUserEnvironment>>;
     /** Which of them this process is. Defaults to `PIKKU_ENV`. */
     environment?: string;
-    persona: string;
+    virtualUserId: string;
     disposition?: string;
     seed?: number;
     goals?: string[];
@@ -104,7 +84,7 @@ export interface StartVirtualUserRunParams {
 /** The recorded run, and the values the dispatch has to carry unchanged. */
 export interface StartedVirtualUserRun {
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     seed: number;
     goals: string[];
@@ -117,7 +97,7 @@ export interface StartedVirtualUserRun {
  * scheduled tick have in common. The dispatch that follows is typed off the
  * app's RPC map, so it stays in the generated wiring.
  */
-export declare const startVirtualUserRun: ({ store, personas, config, environments, environment, persona: personaId, disposition: requested, seed: requestedSeed, goals, memory, startedBy, }: StartVirtualUserRunParams) => Promise<StartedVirtualUserRun>;
+export declare const startVirtualUserRun: ({ store, virtualUsers, config, environments, environment, virtualUserId, disposition: requested, seed: requestedSeed, goals, memory, startedBy, }: StartVirtualUserRunParams) => Promise<StartedVirtualUserRun>;
 /**
  * One run on the wire.
  *
@@ -127,7 +107,7 @@ export declare const startVirtualUserRun: ({ store, personas, config, environmen
  */
 export declare const serializeVirtualUserRun: (run: VirtualUserRunRecord) => {
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     seed: number;
     status: "completed" | "failed" | "running";
@@ -175,8 +155,8 @@ export declare const serializeVirtualUserSteps: (steps: readonly StepRecord[]) =
  * takes; the engine's own duration also accepts `'30m'`, which nothing on this
  * side ever writes.
  */
-export declare const serializeVirtualUserSchedule: (schedule: VirtualUserScheduleRecord, personas: ScaffoldPersonas) => {
-    persona: string;
+export declare const serializeVirtualUserSchedule: (schedule: VirtualUserScheduleRecord, virtualUsers: ScaffoldVirtualUsers) => {
+    virtualUserId: string;
     enabled: boolean;
     disposition: VirtualUserDisposition;
     goals: string[];
@@ -197,8 +177,8 @@ export declare const serializeVirtualUserSchedule: (schedule: VirtualUserSchedul
 };
 export interface WriteVirtualUserScheduleParams {
     store: VirtualUserScheduleStore | undefined;
-    personas: ScaffoldPersonas;
-    persona: string;
+    virtualUsers: ScaffoldVirtualUsers;
+    virtualUserId: string;
     enabled?: boolean;
     disposition?: string;
     goals?: string[];
@@ -214,25 +194,25 @@ export interface WriteVirtualUserScheduleParams {
     config?: {
         nodeEnv?: string;
     };
-    environments?: Readonly<Record<string, PersonaEnvironment>>;
+    environments?: Readonly<Record<string, VirtualUserEnvironment>>;
     environment?: string;
 }
 /**
- * Writes a persona's cadence.
+ * Writes a virtual user's cadence.
  *
  * Applies the same rules `startVirtualUserRun` enforces, at the point the row is
- * written rather than every hour afterwards: an acted-upon persona has no
- * session, and an enabled cadence whose disposition production refuses, so
- * either is a tick that can only ever fail to start, with nobody watching.
+ * written rather than every hour afterwards: an acted-upon virtual user has no
+ * session, and production refuses every run, so either is a tick that can only
+ * ever fail to start, with nobody watching.
  *
- * The disposition checked is the one the row will hold, since a field left out
- * keeps what it had: enabling a row saved earlier as adversarial is refused
- * just as saving one would be.
+ * Whether the row is enabled is the one thing checked, since a field left out
+ * keeps what it had: enabling a row saved earlier is refused just as saving a
+ * new one would be.
  */
-export declare const writeVirtualUserSchedule: ({ store, personas, persona, enabled, disposition, goals, budget, minIntervalMs, maxIntervalMs, nextRunAt, config, environments, environment, }: WriteVirtualUserScheduleParams) => Promise<VirtualUserScheduleRecord>;
+export declare const writeVirtualUserSchedule: ({ store, virtualUsers, virtualUserId, enabled, disposition, goals, budget, minIntervalMs, maxIntervalMs, nextRunAt, config, environments, environment, }: WriteVirtualUserScheduleParams) => Promise<VirtualUserScheduleRecord>;
 /** What a due schedule asks `runVirtualUser` for. */
 export declare const virtualUserScheduleRunInput: (schedule: VirtualUserScheduleRecord) => {
-    persona: string;
+    virtualUserId: string;
     disposition: VirtualUserDisposition;
     goals: string[];
     budget: {
@@ -245,7 +225,7 @@ export declare const virtualUserScheduleRunInput: (schedule: VirtualUserSchedule
  * What a tick did.
  *
  * Logged rather than returned: the caller is a cron, and a run this started is
- * otherwise the only trace that a persona is still out there working.
+ * otherwise the only trace that a virtual user is still out there working.
  */
 export declare const logVirtualUserTick: (logger: Logger, result: VirtualUserTickResult) => void;
 export interface ExecuteVirtualUserRunParams {
@@ -254,11 +234,11 @@ export interface ExecuteVirtualUserRunParams {
     agentRunner: AgentRunnerService | undefined;
     variables: VariablesService;
     logger: Logger;
-    personas: ScaffoldPersonas;
-    /** The app's generated `createPersonas`, which knows its own persona ids. */
-    createPersonas: (options: Omit<HttpPersonasConfig, 'personas'>) => ScenarioPersonas;
+    virtualUsers: ScaffoldVirtualUsers;
+    /** The app's generated `createVirtualUsers`, which knows its own virtual user ids. */
+    createVirtualUsers: (options: Omit<HttpVirtualUsersConfig, 'virtualUsers'>) => ScenarioVirtualUsers;
     runId: string;
-    persona: string;
+    virtualUserId: string;
     disposition: string;
     goals: string[];
     memory: Record<string, string>;
@@ -268,16 +248,17 @@ export interface ExecuteVirtualUserRunParams {
         mutations?: number;
         durationMs?: number;
     };
-    operatorToken?: string;
+    /** The app's auth instance, which a run signs in through without a credential. */
+    auth: InProcessAuth | undefined;
 }
 /**
  * The run itself.
  *
  * Everything it needs is derived through `metaService` and the generated
- * personas — the same public surface any consumer has. Nothing reaches into
+ * virtual users — the same public surface any consumer has. Nothing reaches into
  * pikku's internals, because an app could not, and a feature built on what only
  * the framework can see would not be this feature.
  */
-export declare const executeVirtualUserRun: ({ runStore, metaService, agentRunner, variables, logger, personas, createPersonas, runId, persona: personaId, disposition, goals, memory, seed, budget, operatorToken, }: ExecuteVirtualUserRunParams) => Promise<{
+export declare const executeVirtualUserRun: ({ runStore, metaService, agentRunner, variables, logger, virtualUsers, createVirtualUsers, runId, virtualUserId, disposition, goals, memory, seed, budget, auth, }: ExecuteVirtualUserRunParams) => Promise<{
     findings: number;
 }>;

package/dist/wirings/virtual-user/virtual-user-scaffold.js

@@ -1,9 +1,9 @@
+import { inProcessSignIn, } from '../../services/virtual-user-sign-in.js';
 import { readEnvVariable } from '../../env.js';
 import { BadRequestError, ForbiddenError } from '../../errors/errors.js';
 import { prepareVirtualUserRun } from './prepare-virtual-user-run.js';
 import { runVirtualUser as runVirtualUserEngine } from './run-virtual-user.js';
-import { personaVirtualUserTarget } from './virtual-user-target.js';
-import { PRODUCTION_DISPOSITION } from './virtual-user.types.js';
+import { virtualUserTarget } from './virtual-user-target.js';
 /**
  * The variables a scaffolded run reads.
  *
@@ -18,55 +18,28 @@ export const VIRTUAL_USER_VARIABLES = {
      * somewhere it only assumed was itself.
      */
     apiUrl: 'VIRTUAL_USER_API_URL',
-    secret: 'SCENARIO_ACTOR_SECRET',
     model: 'VIRTUAL_USER_MODEL',
     /**
-     * The same two variables a scenario run reads, because a virtual user signs
-     * in and calls through exactly the doors a scenario does. An app that mounts
-     * auth somewhere other than the root — `/api/auth` is the common one — has no
-     * other way to say so, and without them the run signs in against a 404 and
-     * spends its whole budget thinking about why nothing works.
+     * Where the app serves its exposed RPCs, as a scenario run reads it. An app
+     * that mounts them somewhere other than `/rpc` has no other way to say so.
      */
-    signInPath: 'SCENARIO_SIGN_IN_PATH',
     rpcPath: 'SCENARIO_RPC_PATH',
-    /**
-     * The deployed way in. A Fabric operator token is asymmetric — a stage can
-     * verify one and can never mint one — so unlike the actor secret it is safe
-     * for a run against a real environment. Read from the environment only as the
-     * fallback for a run nobody handed a token to, which is what a schedule is.
-     */
-    operatorToken: 'FABRIC_OPERATOR_TOKEN',
-};
-/**
- * Which door under the auth mount, given the credential in hand.
- *
- * Both are better-auth plugins mounted side by side, so `SCENARIO_SIGN_IN_PATH`
- * names the mount and the last segment is ours to pick — an app that moved auth
- * to `/api/auth` says so once and both paths follow. A path that names neither
- * plugin is left alone, since it was configured deliberately.
- */
-export const signInPathFor = (configured, plugin) => {
-    if (!configured) {
-        return undefined;
-    }
-    const mount = configured.replace(/\/sign-in\/(actor|fabric)$/, '');
-    return mount === configured ? configured : `${mount}/sign-in/${plugin}`;
 };
 /**
- * The declared persona behind an id, refused unless it is one a run may be.
+ * The declared virtual user behind an id, refused unless it is one a run may be.
  *
- * An acted-upon persona has no session of its own, and running one would race
+ * An acted-upon virtual user has no session of its own, and running one would race
  * whatever scenario acts on it.
  */
-export const runnablePersona = (personas, personaId) => {
-    const persona = personas[personaId];
-    if (!persona) {
-        throw new BadRequestError(`Unknown persona "${personaId}" — declare it with definePersonas()`);
+export const runnableVirtualUser = (virtualUsers, virtualUserId) => {
+    const virtualUser = virtualUsers[virtualUserId];
+    if (!virtualUser) {
+        throw new BadRequestError(`Unknown virtual user "${virtualUserId}" — declare it with defineVirtualUsers()`);
     }
-    if (!persona.runnable) {
-        throw new BadRequestError(`Persona "${personaId}" is declared as acted upon, never run`);
+    if (!virtualUser.runnable) {
+        throw new BadRequestError(`VirtualUser "${virtualUserId}" is declared as acted upon, never run`);
     }
-    return persona;
+    return virtualUser;
 };
 const MISSING_RUN_STORE = 'No virtualUserRunStore is wired — a run has nowhere to be recorded. ' +
     'Wire KyselyVirtualUserRunStore from @pikku/kysely, or your own implementation of VirtualUserRunStore.';
@@ -94,7 +67,7 @@ export const requireVirtualUserScheduleStore = (store) => {
  * `NODE_ENV=production` there too — keying on it refuses every disposition on
  * the one environment they exist to be used on. `PIKKU_ENV` names which of the
  * configured environments this is, which is the question actually being asked,
- * and it is the same signal `personaEnvironmentRefusal` already checks at
+ * and it is the same signal `virtualUserEnvironmentRefusal` already checks at
  * sign-in.
  *
  * Unresolved is treated as production: an environment nobody can name is one
@@ -108,12 +81,11 @@ const isProductionRun = (config, environments, environment) => {
     }
     return environment ? Boolean(environments[environment]?.production) : true;
 };
-// Every disposition other than this one exists to find out what the product
-// does wrong, which is not a thing to do to real customers' data.
-const refuseInProduction = (personaId, disposition, config, environments, environment) => {
-    if (disposition !== PRODUCTION_DISPOSITION &&
-        isProductionRun(config, environments, environment)) {
-        throw new ForbiddenError(`Only the '${PRODUCTION_DISPOSITION}' disposition may run against production; "${personaId}" is ${disposition}`);
+// A virtual user is a probe, and probing is not a thing to do to real
+// customers' data, whatever the disposition.
+const refuseInProduction = (virtualUserId, config, environments, environment) => {
+    if (isProductionRun(config, environments, environment)) {
+        throw new ForbiddenError(`Virtual users do not run against production; "${virtualUserId}" cannot run here`);
     }
 };
 /**
@@ -123,15 +95,13 @@ const refuseInProduction = (personaId, disposition, config, environments, enviro
  * scheduled tick have in common. The dispatch that follows is typed off the
  * app's RPC map, so it stays in the generated wiring.
  */
-export const startVirtualUserRun = async ({ store, personas, config, environments, environment = readEnvVariable('PIKKU_ENV'), persona: personaId, disposition: requested, seed: requestedSeed, goals, memory, startedBy, }) => {
+export const startVirtualUserRun = async ({ store, virtualUsers, config, environments, environment = readEnvVariable('PIKKU_ENV'), virtualUserId, disposition: requested, seed: requestedSeed, goals, memory, startedBy, }) => {
     const runStore = requireVirtualUserRunStore(store);
-    const persona = runnablePersona(personas, personaId);
+    const virtualUser = runnableVirtualUser(virtualUsers, virtualUserId);
     const disposition = (requested ??
-        persona.disposition ??
+        virtualUser.disposition ??
         'realistic');
-    // Checked against the effective disposition, so an override cannot smuggle
-    // one in.
-    refuseInProduction(personaId, disposition, config, environments, environment);
+    refuseInProduction(virtualUserId, config, environments, environment);
     // Seeded here rather than inside the engine so the record carries the seed
     // even if the run dies before returning — an unreproducible crash costs the
     // most.
@@ -139,7 +109,7 @@ export const startVirtualUserRun = async ({ store, personas, config, environment
     const resolvedGoals = goals ?? [];
     const resolvedMemory = memory ?? {};
     const runId = await runStore.start({
-        persona: persona.id,
+        virtualUserId: virtualUser.id,
         disposition,
         seed,
         goals: resolvedGoals,
@@ -148,7 +118,7 @@ export const startVirtualUserRun = async ({ store, personas, config, environment
     });
     return {
         runId,
-        persona: persona.id,
+        virtualUserId: virtualUser.id,
         disposition,
         seed,
         goals: resolvedGoals,
@@ -164,7 +134,7 @@ export const startVirtualUserRun = async ({ store, personas, config, environment
  */
 export const serializeVirtualUserRun = (run) => ({
     runId: run.runId,
-    persona: run.persona,
+    virtualUserId: run.virtualUserId,
     disposition: run.disposition,
     seed: run.seed,
     status: run.status,
@@ -212,10 +182,10 @@ export const serializeVirtualUserSteps = (steps) => steps.map((step) => ({
  * takes; the engine's own duration also accepts `'30m'`, which nothing on this
  * side ever writes.
  */
-export const serializeVirtualUserSchedule = (schedule, personas) => {
-    const persona = personas[schedule.persona];
+export const serializeVirtualUserSchedule = (schedule, virtualUsers) => {
+    const virtualUser = virtualUsers[schedule.virtualUserId];
     return {
-        persona: schedule.persona,
+        virtualUserId: schedule.virtualUserId,
         enabled: schedule.enabled,
         disposition: schedule.disposition,
         goals: schedule.goals,
@@ -234,36 +204,36 @@ export const serializeVirtualUserSchedule = (schedule, personas) => {
         lastRunId: schedule.lastRunId,
         lastRunAt: schedule.lastRunAt ? schedule.lastRunAt.toISOString() : null,
         declared: {
-            disposition: (persona?.disposition ??
+            disposition: (virtualUser?.disposition ??
                 'realistic'),
-            goals: persona?.goals ?? [],
+            goals: virtualUser?.goals ?? [],
         },
     };
 };
 /**
- * Writes a persona's cadence.
+ * Writes a virtual user's cadence.
  *
  * Applies the same rules `startVirtualUserRun` enforces, at the point the row is
- * written rather than every hour afterwards: an acted-upon persona has no
- * session, and an enabled cadence whose disposition production refuses, so
- * either is a tick that can only ever fail to start, with nobody watching.
+ * written rather than every hour afterwards: an acted-upon virtual user has no
+ * session, and production refuses every run, so either is a tick that can only
+ * ever fail to start, with nobody watching.
  *
- * The disposition checked is the one the row will hold, since a field left out
- * keeps what it had: enabling a row saved earlier as adversarial is refused
- * just as saving one would be.
+ * Whether the row is enabled is the one thing checked, since a field left out
+ * keeps what it had: enabling a row saved earlier is refused just as saving a
+ * new one would be.
  */
-export const writeVirtualUserSchedule = async ({ store, personas, persona, enabled, disposition, goals, budget, minIntervalMs, maxIntervalMs, nextRunAt, config, environments, environment = readEnvVariable('PIKKU_ENV'), }) => {
+export const writeVirtualUserSchedule = async ({ store, virtualUsers, virtualUserId, enabled, disposition, goals, budget, minIntervalMs, maxIntervalMs, nextRunAt, config, environments, environment = readEnvVariable('PIKKU_ENV'), }) => {
     const scheduleStore = requireVirtualUserScheduleStore(store);
-    const declared = runnablePersona(personas, persona);
+    const declared = runnableVirtualUser(virtualUsers, virtualUserId);
     const current = enabled === undefined || disposition === undefined
-        ? await scheduleStore.get(persona)
+        ? await scheduleStore.get(virtualUserId)
         : null;
     const created = disposition === undefined && !current ? declared.disposition : undefined;
     if (enabled ?? current?.enabled) {
-        refuseInProduction(persona, disposition ?? current?.disposition ?? created ?? 'realistic', config, environments, environment);
+        refuseInProduction(virtualUserId, config, environments, environment);
     }
     return scheduleStore.set({
-        persona,
+        virtualUserId,
         enabled,
         disposition: (disposition ?? created),
         goals,
@@ -283,7 +253,7 @@ export const writeVirtualUserSchedule = async ({ store, personas, persona, enabl
 };
 /** What a due schedule asks `runVirtualUser` for. */
 export const virtualUserScheduleRunInput = (schedule) => ({
-    persona: schedule.persona,
+    virtualUserId: schedule.virtualUserId,
     disposition: schedule.disposition,
     goals: schedule.goals,
     budget: schedule.budget
@@ -300,28 +270,28 @@ export const virtualUserScheduleRunInput = (schedule) => ({
  * What a tick did.
  *
  * Logged rather than returned: the caller is a cron, and a run this started is
- * otherwise the only trace that a persona is still out there working.
+ * otherwise the only trace that a virtual user is still out there working.
  */
 export const logVirtualUserTick = (logger, result) => {
-    for (const { persona, runId } of result.dispatched) {
-        logger.info(`Virtual user ${persona} started run ${runId} on schedule`);
+    for (const { virtualUserId, runId } of result.dispatched) {
+        logger.info(`Virtual user ${virtualUserId} started run ${runId} on schedule`);
     }
     for (const runId of result.reaped) {
-        logger.warn(`Virtual user run ${runId} was abandoned — marked failed so its persona can run again`);
+        logger.warn(`Virtual user run ${runId} was abandoned — marked failed so its virtual user can run again`);
     }
-    for (const { persona, reason } of result.skipped) {
-        logger.info(`Virtual user ${persona} skipped this tick: ${reason}`);
+    for (const { virtualUserId, reason } of result.skipped) {
+        logger.info(`Virtual user ${virtualUserId} skipped this tick: ${reason}`);
     }
 };
 /**
  * The run itself.
  *
  * Everything it needs is derived through `metaService` and the generated
- * personas — the same public surface any consumer has. Nothing reaches into
+ * virtual users — the same public surface any consumer has. Nothing reaches into
  * pikku's internals, because an app could not, and a feature built on what only
  * the framework can see would not be this feature.
  */
-export const executeVirtualUserRun = async ({ runStore, metaService, agentRunner, variables, logger, personas, createPersonas, runId, persona: personaId, disposition, goals, memory, seed, budget, operatorToken, }) => {
+export const executeVirtualUserRun = async ({ runStore, metaService, agentRunner, variables, logger, virtualUsers, createVirtualUsers, runId, virtualUserId, disposition, goals, memory, seed, budget, auth, }) => {
     const store = requireVirtualUserRunStore(runStore);
     try {
         if (!metaService) {
@@ -332,20 +302,11 @@ export const executeVirtualUserRun = async ({ runStore, metaService, agentRunner
         }
         const apiUrl = await variables.get(VIRTUAL_USER_VARIABLES.apiUrl);
         if (!apiUrl) {
-            throw new Error(`${VIRTUAL_USER_VARIABLES.apiUrl} is not set — a virtual user has no address to sign in at.`);
+            throw new Error(`${VIRTUAL_USER_VARIABLES.apiUrl} is not set, so the virtual user has no address to drive. ` +
+                `Set it to the URL this app is reached at, including any HTTP prefix (for example https://my-app.example.com/api). \`pikku dev\` sets it for you.`);
         }
-        // An operator token wins wherever one is available: it is asymmetric, and
-        // it does not need the target to hold a shared secret at all. The actor
-        // secret is the local-only fallback, because only `pikku dev` serves the
-        // endpoint that accepts it.
-        const token = operatorToken ??
-            (await variables.get(VIRTUAL_USER_VARIABLES.operatorToken));
-        const secret = token
-            ? undefined
-            : await variables.get(VIRTUAL_USER_VARIABLES.secret);
-        if (!token && !secret) {
-            throw new Error(`Neither an operator token nor ${VIRTUAL_USER_VARIABLES.secret} is available — there is nobody for the virtual user to be. ` +
-                `Hand a Fabric operator token in with the run against a deployed stage, or export ${VIRTUAL_USER_VARIABLES.secret} against a local \`pikku dev\` target.`);
+        if (!auth) {
+            throw new Error('The app has no auth service, so the virtual user has no way to sign in. Register better-auth (with the pikkuVirtualUser plugin) as the auth singleton service.');
         }
         const model = await variables.get(VIRTUAL_USER_VARIABLES.model);
         if (!model) {
@@ -358,40 +319,31 @@ export const executeVirtualUserRun = async ({ runStore, metaService, agentRunner
             ...new Set(Object.values(functionsMeta).flatMap((meta) => [meta.inputSchemaName, meta.outputSchemaName].filter((name) => !!name))),
         ];
         const schemas = (await metaService.getSchemas(schemaNames));
-        const persona = personas[personaId];
-        if (!persona) {
-            throw new Error(`Persona "${personaId}" is no longer declared`);
+        const virtualUser = virtualUsers[virtualUserId];
+        if (!virtualUser) {
+            throw new Error(`VirtualUser "${virtualUserId}" is no longer declared`);
         }
         const { catalogue, intents, agents } = prepareVirtualUserRun({
-            persona,
+            virtualUser,
             functionsMeta,
             schemas,
             workflowsMeta: await metaService.getWorkflowMeta(),
             systemRoles: await metaService.getSystemRolesMeta(),
             agentsMeta: await metaService.getAgentsMeta(),
         });
-        const configuredSignInPath = (await variables.get(VIRTUAL_USER_VARIABLES.signInPath)) ?? undefined;
-        const signedIn = createPersonas({
+        const signedIn = createVirtualUsers({
             apiUrl,
-            ...(token
-                ? {
-                    operator: {
-                        token,
-                        signInPath: signInPathFor(configuredSignInPath, 'fabric'),
-                    },
-                }
-                : { secret }),
+            signIn: inProcessSignIn(auth),
             model,
-            signInPath: signInPathFor(configuredSignInPath, 'actor'),
             rpcPath: (await variables.get(VIRTUAL_USER_VARIABLES.rpcPath)) ?? undefined,
         });
-        const target = signedIn[personaId];
+        const target = signedIn[virtualUserId];
         if (!target) {
-            throw new Error(`Persona "${personaId}" cannot sign in`);
+            throw new Error(`VirtualUser "${virtualUserId}" cannot sign in`);
         }
         const result = await runVirtualUserEngine({
-            persona,
-            personaId,
+            virtualUser,
+            virtualUserId,
             disposition: disposition,
             catalogue,
             intents,
@@ -399,11 +351,11 @@ export const executeVirtualUserRun = async ({ runStore, metaService, agentRunner
             memory,
             seed,
             agents,
-            target: personaVirtualUserTarget(target, {
+            target: virtualUserTarget(target, {
                 model,
                 agents: agents.map((agent) => agent.name),
             }),
-            // `AgentRunnerService.run` IS the engine's `ActorLLM` — same params, same
+            // `AgentRunnerService.run` IS the engine's `VirtualUserLLM` — same params, same
             // result — so a virtual user thinks through the same runner every agent in
             // the app does, provider quirks and all.
             llm: (params) => agentRunner.run(params),
@@ -429,7 +381,7 @@ export const executeVirtualUserRun = async ({ runStore, metaService, agentRunner
         // record is the only place that distinction survives — leaving it at
         // 'running' forever is what `fail` exists to prevent.
         const message = error instanceof Error ? error.message : String(error);
-        logger.error(`Virtual user run ${runId} (${personaId}) failed: ${message}`);
+        logger.error(`Virtual user run ${runId} (${virtualUserId}) failed: ${message}`);
         await store.fail(runId, message);
         throw error;
     }