@pikku/cli 0.12.96 → 0.12.100

package/dist/src/functions/commands/deploy-plan.d.ts

@@ -8,7 +8,7 @@ export declare const deployPlan: import("#pikku").PikkuFunctionConfig<{
     provider?: string;
     runtime?: string;
     debugArtifacts?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     resultFile?: string;
     provider?: string;
     runtime?: string;

package/dist/src/functions/commands/dev.d.ts

@@ -10,7 +10,7 @@ export declare const dev: import("#pikku").PikkuFunctionConfig<{
     hmr?: boolean;
     coverage?: boolean;
     test?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     port?: string;
     watch?: boolean;
     hmr?: boolean;

package/dist/src/functions/commands/dev.js

@@ -5,7 +5,7 @@ import { pikkuDevReloader, reloadGeneratedMeta, reconcileAddonRegistry, } from '
 import { ConsoleLogger, LocalEmailService, spy, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, QueueWebhookService, } from '@pikku/core/services';
 import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
 import { stopSingletonServices } from '@pikku/core';
-import { pikkuState } from '@pikku/core/internal';
+import { pikkuState } from '@pikku/core/ecosystem';
 import { LocalMetaService } from '@pikku/core/services/local-meta';
 import { LocalContent, } from '@pikku/core/services/local-content';
 import { InMemorySchedulerService } from '@pikku/schedule';
@@ -135,7 +135,7 @@ export const dev = pikkuSessionlessFunc({
         const effectiveDbConfig = envDatabaseUrl
             ? parseDatabaseUrl(envDatabaseUrl)
             : userConfig;
-        const resolvedDb = resolveDb(effectiveDbConfig, config.rootDir, config.outDir, config.runtimeDir);
+        const resolvedDb = resolveDb(effectiveDbConfig, config.rootDir, config.outDir, config.runtimeDir, config.db);
         const resolvedLocalDb = resolvedDb ?? undefined;
         const kysely = resolvedLocalDb
             ? await createKysely(resolvedLocalDb)

package/dist/src/functions/commands/emails-init.d.ts

@@ -1,5 +1,5 @@
 type EmailsInitInput = {
     force?: boolean;
 };
-export declare const pikkuEmailsInit: import("#pikku").PikkuFunctionConfig<EmailsInitInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<EmailsInitInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<EmailsInitInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuEmailsInit: import("#pikku").PikkuFunctionConfig<EmailsInitInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<EmailsInitInput, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<EmailsInitInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export {};

package/dist/src/functions/commands/enable.d.ts

@@ -1,8 +1,8 @@
-export declare const enableRpc: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const enableConsole: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const enableScenarios: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const enableAgent: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const enableWorkflow: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const enableEvents: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const enableRemoteRpc: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const enableWebhook: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const enableRpc: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const enableConsole: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const enableScenarios: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const enableAgent: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const enableWorkflow: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const enableEvents: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const enableRemoteRpc: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;
+export declare const enableWebhook: import("#pikku").PikkuFunctionSessionlessConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown>, undefined, undefined>;

package/dist/src/functions/commands/import-n8n.d.ts

@@ -4,7 +4,7 @@ export declare const pikkuImportN8n: import("#pikku").PikkuFunctionConfig<{
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     file: string;
     out?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     file: string;
     out?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/info.d.ts

@@ -2,8 +2,8 @@ type InfoInput = {
     limit?: string;
     verbose?: boolean;
 };
-export declare const pikkuInfoFunctions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuInfoTags: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuInfoMiddleware: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuInfoPermissions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuInfoFunctions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuInfoTags: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuInfoMiddleware: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuInfoPermissions: import("#pikku").PikkuFunctionConfig<InfoInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<InfoInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export {};

package/dist/src/functions/commands/knowledge-index.d.ts

@@ -17,7 +17,7 @@ export declare const knowledgeIndex: import("#pikku").PikkuFunctionConfig<{
         path: string;
         action: "unchanged" | "created" | "updated";
     }[];
-}, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     check?: boolean | undefined;
 }, {
     ok: boolean;

package/dist/src/functions/commands/knowledge-validate.d.ts

@@ -19,7 +19,7 @@ export declare const knowledgeValidate: import("#pikku").PikkuFunctionConfig<Rec
         path: string;
         fixHint: string;
     }[];
-}, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<Record<string, never>, {
+}, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<Record<string, never>, {
     ok: boolean;
     notes: number;
     findings: {

package/dist/src/functions/commands/login.d.ts

@@ -11,7 +11,7 @@ interface LoginOptions {
  * `~/.pikku/session.json`; generated CLI/websocket clients pick it up
  * automatically.
  */
-export declare const login: import("#pikku").PikkuFunctionConfig<LoginOptions, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<LoginOptions, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<LoginOptions, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const login: import("#pikku").PikkuFunctionConfig<LoginOptions, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<LoginOptions, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<LoginOptions, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /**
  * `pikku logout` — remove a stored session (the given `--url`, or the current
  * default).
@@ -20,7 +20,7 @@ export declare const logout: import("#pikku").PikkuFunctionConfig<{
     url?: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     url?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     url?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /**
@@ -31,7 +31,7 @@ export declare const whoami: import("#pikku").PikkuFunctionConfig<{
     url?: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     url?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     url?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export {};

package/dist/src/functions/commands/meta.d.ts

@@ -1,56 +1,56 @@
-export declare const pikkuMetaFunctionsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaFunctionsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const pikkuMetaFunctionsGet: import("#pikku").PikkuFunctionConfig<{
     functionId: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     functionId: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     functionId: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaSchemasList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaSchemasList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const pikkuMetaSchemasGet: import("#pikku").PikkuFunctionConfig<{
     schemaName: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     schemaName: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     schemaName: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaWorkflowsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWorkflowsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const pikkuMetaWorkflowsGet: import("#pikku").PikkuFunctionConfig<{
     workflowId: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     workflowId: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     workflowId: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaMiddlewareList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaMiddlewareList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const pikkuMetaMiddlewareGet: import("#pikku").PikkuFunctionConfig<{
     middlewareId: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     middlewareId: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     middlewareId: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaPermissionsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaPermissionsList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const pikkuMetaPermissionsGet: import("#pikku").PikkuFunctionConfig<{
     permissionId: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     permissionId: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     permissionId: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaWiresList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const pikkuMetaWiresType: import("#pikku").PikkuFunctionConfig<{
     type: string;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     type: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     type: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaWiresHttp: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaWiresScheduler: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaWiresQueue: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaWiresChannel: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuMetaWiresTrigger: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresHttp: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresScheduler: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresQueue: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresChannel: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaWiresTrigger: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /**
  * Bulk context endpoint.
  *
@@ -63,7 +63,7 @@ export declare const pikkuMetaWiresTrigger: import("#pikku").PikkuFunctionConfig
  * Targeted `pikku meta * get` calls are still the right tool when the planner
  * wants schema details (input/output JSON schemas) for a specific entry.
  */
-export declare const pikkuMetaContext: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaContext: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /**
  * Frontend-targeted metadata.
  *
@@ -79,4 +79,4 @@ export declare const pikkuMetaContext: import("#pikku").PikkuFunctionConfig<{},
  * non-exposed functions, http wires) is a backend concern and stays in
  * `pikku meta context`.
  */
-export declare const pikkuMetaClients: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuMetaClients: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/new-addon.d.ts

@@ -57,7 +57,7 @@ export declare const pikkuNewAddon: import("#pikku").PikkuFunctionConfig<{
     authConfig?: string;
     mcp?: boolean;
     camelCase?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     name: string;
     displayName?: string;
     description?: string;

package/dist/src/functions/commands/new-addon.js

@@ -308,10 +308,10 @@ import { pikkuAddonServices } from '#pikku'
 
 export const createSingletonServices = pikkuAddonServices(async (
   config,
-  { secrets, variables }
+  { secrets }
 ) => {
   const creds = await secrets.getSecret<${pascalName}Secrets>('${screamingName}_CREDENTIALS')
-  const ${camelName} = new ${pascalName}Service(creds, variables)
+  const ${camelName} = new ${pascalName}Service(creds.reveal())
 
   return { ${camelName} }
 })

package/dist/src/functions/commands/new-function.d.ts

@@ -4,7 +4,7 @@ export declare const pikkuNewFunction: import("#pikku").PikkuFunctionConfig<{
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     type?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     name: string;
     type?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/new-middleware.d.ts

@@ -4,7 +4,7 @@ export declare const pikkuNewMiddleware: import("#pikku").PikkuFunctionConfig<{
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     type?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     name: string;
     type?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/new-permission.d.ts

@@ -4,7 +4,7 @@ export declare const pikkuNewPermission: import("#pikku").PikkuFunctionConfig<{
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     type?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     name: string;
     type?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/new-wiring.d.ts

@@ -4,7 +4,7 @@ export declare const pikkuNewWiring: import("#pikku").PikkuFunctionConfig<{
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     name: string;
     type?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     name: string;
     type?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/persona-sync.d.ts

@@ -2,7 +2,7 @@
  * Provision the declared personas into an environment: their accounts, and the
  * roles they declare.
  *
- * This is deployment, not seeding. `pikku db seed` applies a project's test
+ * This is deployment, not seeding. `pikku db reset` applies a project's test
  * fixtures and does not run in production; an accountable persona doing a real
  * job in production still needs an account and its grants, and this is where
  * they come from.
@@ -26,7 +26,7 @@ export declare const personaSync: import("#pikku").PikkuFunctionConfig<{
     environment: string;
     apiUrl?: string;
     dryRun?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     environment: string;
     apiUrl?: string;
     dryRun?: boolean;

package/dist/src/functions/commands/persona-sync.js

@@ -26,7 +26,7 @@ const userIdByEmail = async (db, email) => {
  * Provision the declared personas into an environment: their accounts, and the
  * roles they declare.
  *
- * This is deployment, not seeding. `pikku db seed` applies a project's test
+ * This is deployment, not seeding. `pikku db reset` applies a project's test
  * fixtures and does not run in production; an accountable persona doing a real
  * job in production still needs an account and its grants, and this is where
  * they come from.

package/dist/src/functions/commands/persona.d.ts

@@ -39,7 +39,7 @@ export declare const personaRun: import("#pikku").PikkuFunctionConfig<{
     allowApproval?: boolean;
     skipRoleCheck?: boolean;
     out?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     environment: string;
     persona: string;
     disposition?: string;
@@ -55,4 +55,4 @@ export declare const personaRun: import("#pikku").PikkuFunctionConfig<{
     out?: string;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 /** Who this app is for, and what each of them wants, without running anything. */
-export declare const personaList: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const personaList: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/persona.js

@@ -2,9 +2,8 @@ import { resolve, dirname } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku';
 import { createHttpPersonas, personaEnvironmentRefusal, roleMismatchMessage, verifyPersonaRoles, } from '@pikku/core/persona';
-import { flattenSystemRoleDefinitions } from '@pikku/core/role';
-import { personaVirtualUserTarget, catalogueClassification, deriveCatalogue, deriveIntents, DISPOSITIONS, reachableAgents, runVirtualUser, } from '@pikku/core/virtual-user';
-import { personaScopes, resolvePersonas } from '../../utils/resolve-personas.js';
+import { personaVirtualUserTarget, catalogueClassification, DISPOSITIONS, prepareVirtualUserRun, runVirtualUser, } from '@pikku/core/virtual-user';
+import { resolvePersonas } from '../../utils/resolve-personas.js';
 import { resolveEnvironment } from './environment.js';
 import { createDevAIAgentRunner } from './dev-ai-runner.js';
 import { formatVirtualUserReport } from './virtual-user-formatter.js';
@@ -93,23 +92,21 @@ export const personaRun = pikkuSessionlessFunc({
         if (!aiAgentRunner) {
             throw new Error('No AI provider is configured. Set OPENAI_BASE_URL + OPENAI_API_KEY (or LITELLM_PROXY_URL + LITELLM_API_KEY).');
         }
-        const functionsMeta = state.functions?.meta ?? {};
-        const catalogue = deriveCatalogue(functionsMeta, (state.schemas ?? {}));
+        // Shared with the scaffolded `runVirtualUser` RPC, which does the same
+        // derivation from `metaService` at runtime — the two have to agree, or the
+        // same persona and seed explore a different API depending on how it was
+        // started.
+        const { catalogue, intents, scopes, agents } = prepareVirtualUserRun({
+            persona,
+            functionsMeta: state.functions?.meta ?? {},
+            schemas: (state.schemas ?? {}),
+            workflowsMeta: state.workflows?.meta ?? {},
+            systemRoles: state.systemRoles?.definitions ?? [],
+            agentsMeta: state.agents?.agentsMeta ?? {},
+        });
         if (catalogue.length === 0) {
             throw new Error('This project exposes no RPCs, so there is nothing for a virtual user to do.');
         }
-        const intents = deriveIntents(state.workflows?.meta ?? {}, functionsMeta);
-        // Roles are what a persona declares; scopes are what a function checks.
-        // Expanded once, here, from the same definitions the seed grants from.
-        const roleScopes = {};
-        for (const role of flattenSystemRoleDefinitions(state.systemRoles?.definitions ?? [])) {
-            roleScopes[role.name] = role.scopes;
-        }
-        const scopes = personaScopes(persona, roleScopes);
-        // Gated by the same scopes as the RPCs, because an agent is reached rather
-        // than declared: `CoreAIAgent.scopes` is checked against the session, so a
-        // persona finds the specialists its roles unlock and no others.
-        const agents = reachableAgents(state.agents?.agentsMeta ?? {}, scopes);
         const signedIn = createHttpPersonas({
             apiUrl: env.apiUrl,
             secret,
@@ -173,7 +170,8 @@ export const personaRun = pikkuSessionlessFunc({
             apiUrl: env.apiUrl,
             catalogue: catalogueClassification(catalogue),
         })) {
-            logger[level](text);
+            const write = logger[level].bind(logger);
+            write(text);
         }
         if (out) {
             const path = resolve(config.rootDir, out);

package/dist/src/functions/commands/pikku-command-bootstrap.d.ts

@@ -1,4 +1,4 @@
 export type BootstrapInput = {
     allImports: string[];
 };
-export declare const pikkuBootstrap: import("#pikku").PikkuFunctionConfig<BootstrapInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<BootstrapInput, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<BootstrapInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuBootstrap: import("#pikku").PikkuFunctionConfig<BootstrapInput, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<BootstrapInput, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<BootstrapInput, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/pikku-command-summary.d.ts

@@ -1 +1 @@
-export declare const pikkuSummary: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const pikkuSummary: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/roles-audit.d.ts

@@ -1 +1 @@
-export declare const rolesAudit: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const rolesAudit: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/roles-prune.d.ts

@@ -11,6 +11,6 @@ export declare const rolesPrune: import("#pikku").PikkuFunctionConfig<{
     yes?: boolean;
 }, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     yes?: boolean;
 }, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;

package/dist/src/functions/commands/scenario-ladder.js

@@ -49,7 +49,7 @@ export const collectScenarioStepProse = (workflowMeta, functionsMeta) => {
     for (const step of walkScenarioSteps(workflowMeta?.steps)) {
         const stepMeta = functionsMeta[step.stepFunc];
         const parts = {
-            phase: step.phase ?? 'step',
+            phase: step.phase,
             description: step.options?.description ?? stepMeta?.description ?? step.stepName,
             // A call-site description is an explicit override, so it wins over the
             // step's template the same way it wins over its description.

package/dist/src/functions/commands/scenario.d.ts

@@ -1,5 +1,5 @@
 import type { ScenarioSurface } from '@pikku/core/workflow';
-export declare const scenarioList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const scenarioList: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
 export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     environment: string;
     flows?: string;
@@ -30,7 +30,7 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     trace?: boolean;
     apiUrl?: string;
     appUrl?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
     environment: string;
     flows?: string;
     features?: string;

package/dist/src/functions/commands/scenario.js

@@ -4,7 +4,7 @@ import { pikkuSessionlessFunc } from '#pikku';
 import { InMemoryWorkflowService } from '@pikku/core/services';
 import { createHttpPersonas } from '@pikku/core/persona';
 import { PikkuScenarioService } from '@pikku/core/scenario';
-import { pikkuState, getAllPackageStates } from '@pikku/core/internal';
+import { pikkuState, getAllPackageStates } from '@pikku/core/ecosystem';
 import { resolveFeatureScenarios } from '@pikku/core/workflow';
 import { loadScenarioBootstrap } from './load-user-project.js';
 import { collectScenarioStepProse, scenarioBrowserSteps, scenarioFailureFromSteps, scenarioStepRows, scenarioStepsWithoutBinding, scenarioSurfaceCoverage, } from './scenario-ladder.js';
@@ -254,11 +254,29 @@ export const scenarioRun = pikkuSessionlessFunc({
             workflowRunService: workflowService,
             ...(aiAgentRunner ? { aiAgentRunner } : {}),
         });
+        const refuseInternal = (rpcName) => {
+            throw new Error(`Scenario tried to run '${rpcName}' as an internal step. Every workflow.do ` +
+                `in a scenario must carry { actor: actors.x } so it executes against ` +
+                `'${environment}' (${env.apiUrl}), not local services.`);
+        };
+        // `rpcWithWire` is named alongside `PikkuRPC` rather than left to it: the
+        // workflow runner reaches for that member through an internally untyped
+        // path, so it is the one the guard actually has to answer, and the type
+        // that declares it publicly arrives later in this stack.
         const guardRpc = {
-            rpcWithWire: async (rpcName) => {
-                throw new Error(`Scenario tried to run '${rpcName}' as an internal step. Every workflow.do ` +
-                    `in a scenario must carry { actor: actors.x } so it executes against ` +
-                    `'${environment}' (${env.apiUrl}), not local services.`);
+            depth: 0,
+            global: false,
+            invoke: async (rpcName) => refuseInternal(rpcName),
+            remote: async (rpcName) => refuseInternal(rpcName),
+            exposed: async (rpcName) => refuseInternal(rpcName),
+            rpcWithWire: async (rpcName) => refuseInternal(rpcName),
+            startWorkflow: async (name) => refuseInternal(name),
+            agent: {
+                run: async (name) => refuseInternal(name),
+                stream: async (name) => refuseInternal(name),
+                resume: async (runId) => refuseInternal(runId),
+                approve: async (runId) => refuseInternal(runId),
+                interrupt: async (runId) => refuseInternal(runId),
             },
         };
         // Only a browser run launches one. Under `--run default` a step with a
@@ -334,10 +352,18 @@ export const scenarioRun = pikkuSessionlessFunc({
          * grouping, not something durable. It gets the same three arguments a
          * scenario body gets, the CLI's own singletons included, and its result is
          * discarded.
+         *
+         * The context is *feature*-scoped: `before` and `after` of one feature share
+         * it, so setup can hand teardown the ids it created. It is deliberately not
+         * the context the scenarios in the group see — sharing one bag across a
+         * group is the invisible coupling a Cucumber world had.
          */
         const singletonServices = pikkuState(null, 'package', 'singletonServices');
-        const runFeatureHook = async (hook) => {
-            await hook(singletonServices, undefined, { actors });
+        const runFeatureHook = async (hook, context) => {
+            await hook(singletonServices, undefined, {
+                actors,
+                scenario: { context },
+            });
         };
         const hookFailures = [];
         const runEntry = async (label, scenarioName, data) => {
@@ -428,10 +454,11 @@ export const scenarioRun = pikkuSessionlessFunc({
                     ? `${groupName} › ${entry.scenarioName}${data}`
                     : entry.scenarioName;
             };
+            const featureContext = {};
             let beforeError;
             if (group.before) {
                 try {
-                    await runFeatureHook(group.before);
+                    await runFeatureHook(group.before, featureContext);
                 }
                 catch (e) {
                     beforeError = e;
@@ -459,7 +486,7 @@ export const scenarioRun = pikkuSessionlessFunc({
             finally {
                 if (group.after) {
                     try {
-                        await runFeatureHook(group.after);
+                        await runFeatureHook(group.after, featureContext);
                     }
                     catch (e) {
                         hookFailures.push(`feature '${groupName}' after hook failed: ${e?.message ?? e}`);
@@ -484,7 +511,8 @@ export const scenarioRun = pikkuSessionlessFunc({
             trace,
             projectRoot: config.rootDir,
         })) {
-            logger[level](text);
+            const write = logger[level].bind(logger);
+            write(text);
         }
         // How much of the run actually happened on the surface it targeted. Every
         // step counts, so a step that fell back to the server lowers the ratio
@@ -505,7 +533,8 @@ export const scenarioRun = pikkuSessionlessFunc({
                 logger.info(line);
             }
             else {
-                logger[strict ? 'error' : 'warn'](`${line} — asserted server-side only: ${[...unwitnessed].join(', ')}`);
+                const write = logger[strict ? 'error' : 'warn'].bind(logger);
+                write(`${line} — asserted server-side only: ${[...unwitnessed].join(', ')}`);
             }
         }
         const failed = results.filter((r) => r.status === 'failed');

package/dist/src/functions/commands/scopes-audit.d.ts

@@ -1 +1 @@
-export declare const scopesAudit: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const scopesAudit: import("#pikku").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;