@pikku/cli 0.12.103 → 0.12.105

package/dist/src/cli.wiring.js

@@ -29,6 +29,8 @@ import { scopesPrune } from './functions/commands/scopes-prune.js';
 import { rolesAudit } from './functions/commands/roles-audit.js';
 import { rolesPrune } from './functions/commands/roles-prune.js';
 import { pikkuAudit } from './functions/commands/audit.js';
+import { pikkuSemver } from './functions/commands/semver.js';
+import { renderSemver } from './functions/commands/semver-render.js';
 import { validate, renderValidate } from './functions/commands/validate.js';
 import { knowledgeValidate, renderKnowledgeValidate, } from './functions/commands/knowledge-validate.js';
 import { knowledgeIndex, renderKnowledgeIndex, } from './functions/commands/knowledge-index.js';
@@ -39,6 +41,8 @@ import { pikkuVersionsInit } from './functions/commands/versions-init.js';
 import { pikkuEmailsInit } from './functions/commands/emails-init.js';
 import { pikkuVersionsCheck } from './functions/commands/versions-check.js';
 import { pikkuVersionsUpdate } from './functions/commands/versions-update.js';
+import { pikkuUpdate } from './functions/commands/update.js';
+import { renderUpdate } from './functions/commands/update-render.js';
 import { pikkuNewFunction } from './functions/commands/new-function.js';
 import { pikkuNewWiring } from './functions/commands/new-wiring.js';
 import { pikkuNewMiddleware } from './functions/commands/new-middleware.js';
@@ -205,6 +209,52 @@ wireCLI({
                 },
             },
         }),
+        update: pikkuCLICommand({
+            func: pikkuUpdate,
+            render: renderUpdate,
+            description: 'Report which @pikku/* dependencies can be updated, and the peers those updates need. Reports only until --update is passed',
+            options: {
+                update: {
+                    description: 'Write the new ranges into every package.json covered by the run. Without it, update only reports',
+                    default: false,
+                },
+                updatePeers: {
+                    description: "Also write the ranges unsatisfied peers require (e.g. bumping 'ai' for @pikku/ai-vercel). Implies --update, and can cross a major version of a third-party package",
+                    default: false,
+                },
+                install: {
+                    description: 'After writing, run an install with the package manager the lockfile names. --no-install leaves node_modules alone',
+                    default: true,
+                },
+                tag: {
+                    description: "Dist-tag to update to (default: 'latest')",
+                    default: 'latest',
+                },
+                registry: {
+                    description: 'Registry to read versions from (default: npm_config_registry, else https://registry.npmjs.org)',
+                },
+            },
+        }),
+        semver: pikkuCLICommand({
+            func: pikkuSemver,
+            render: renderSemver,
+            description: "Derive the release semver by comparing this build's surface against a deployed one; writes .pikku/changes.gen.json",
+            options: {
+                against: {
+                    description: 'Baseline to compare against: a .pikku directory, a snapshot file, or a snapshot URL',
+                },
+                emit: {
+                    description: "Produce this build's surface snapshot instead of comparing — publish it to serve as a baseline. Pair with --out; without it the snapshot goes to stdout after the CLI banner",
+                    default: false,
+                },
+                out: {
+                    description: 'Where to write the output (defaults to .pikku/changes.gen.json; with --emit, stdout)',
+                },
+                failOn: {
+                    description: 'Exit non-zero when the verdict is at or above this level: major, minor or patch',
+                },
+            },
+        }),
         watch: pikkuCLICommand({
             func: watch,
             description: 'Watch for file changes and regenerate automatically',
@@ -464,10 +514,6 @@ wireCLI({
                             description: 'Reset/snapshot server coverage per scenario (target must run with --coverage); writes coverage/scenario-coverage.json',
                             default: false,
                         },
-                        browser: {
-                            description: 'Shorthand for --run default when false: takes the server-side path instead of driving a browser',
-                            default: true,
-                        },
                         run: {
                             description: "Which surface every actor drives the system through: 'browser' (as a human), 'cli' (over the websocket), or 'default' (server-side, the fast path)",
                             default: 'default',

package/dist/src/deploy/analyzer/analyzer.js

@@ -146,8 +146,8 @@ export function analyzeDeployment(state, options) {
         const subAgentUnitNames = subAgentNames.map((sa) => `agent-${toSafeKebab(sa)}`);
         // Agent needs AI services
         const agentServices = [
-            { capability: 'ai-model', sourceServiceName: 'aiAgentRunner' },
-            { capability: 'ai-storage', sourceServiceName: 'aiStorage' },
+            { capability: 'ai-model', sourceServiceName: 'agentRunner' },
+            { capability: 'ai-storage', sourceServiceName: 'agentStorage' },
         ];
         // Concrete routes for this agent via catch-all
         const agentRoutes = [
@@ -185,7 +185,7 @@ export function analyzeDeployment(state, options) {
         agents.push({
             // The registry KEY (export name, e.g. `kanbanAgent`), NOT the
             // human-facing `agentMeta.name` (e.g. `kanban-agent`). Routes,
-            // `addAIAgent(...)`, and the inspector-state name filter all key off
+            // `addAgent(...)`, and the inspector-state name filter all key off
             // this identifier — per-unit codegen passes it to `--names`, and the
             // filter matches it against the `agentsMeta` key. Using the human name
             // here makes the filter prune the agent, so its registration never gets
@@ -558,9 +558,9 @@ const SERVICE_CAPABILITY_MAP = {
     content: 'object-storage',
     storage: 'object-storage',
     queueService: 'queue',
-    aiAgentRunner: 'ai-model',
+    agentRunner: 'ai-model',
     ai: 'ai-model',
-    aiStorage: 'ai-storage',
+    agentStorage: 'ai-storage',
     workflowService: 'workflow-state',
     workflow: 'workflow-state',
     credentialService: 'credential-store',

package/dist/src/deploy/bundler/bundler.js

@@ -31,12 +31,12 @@ const SERVICE_GEN_FILE_MAP = {
  * keeps their (often large) trees out of the bundle.
  *
  * The AI SDKs (@pikku/ai-vercel + @ai-sdk/* + `ai`, ~3MB) are only constructed
- * when `aiAgentRunner` is wired (agent units). Every non-agent unit stubs them.
+ * when `agentRunner` is wired (agent units). Every non-agent unit stubs them.
  * The shared services factory must guard the runner construction behind a
  * defined-check on the dynamic import so a stubbed unit simply skips it.
  */
 const SERVICE_MODULE_MAP = {
-    aiAgentRunner: [/^@pikku\/ai-vercel/, /^@ai-sdk\//, /^ai$/],
+    agentRunner: [/^@pikku\/ai-vercel/, /^@ai-sdk\//, /^ai$/],
 };
 /**
  * Read the per-unit pikku-services.gen.ts and return the set of gen file

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

@@ -48,7 +48,9 @@ function runBun(args, cwd) {
 }
 function normaliseSeverity(sev) {
     const s = String(sev ?? '').toLowerCase();
-    return SEVERITY_ORDER.includes(s) ? s : 'info';
+    return SEVERITY_ORDER.includes(s)
+        ? s
+        : 'info';
 }
 // bun audit --json → { "<pkg>": [ { id, url, title, severity, vulnerable_versions, cwe[], cvss:{score} } ] }
 function parseBunAudit(raw) {
@@ -61,7 +63,9 @@ function parseBunAudit(raw) {
     catch {
         return issues;
     }
-    const map = obj && typeof obj.advisories === 'object' && obj.advisories ? obj.advisories : obj;
+    const map = obj && typeof obj.advisories === 'object' && obj.advisories
+        ? obj.advisories
+        : obj;
     if (!map || typeof map !== 'object')
         return issues;
     for (const [pkg, list] of Object.entries(map)) {
@@ -77,7 +81,9 @@ function parseBunAudit(raw) {
                 url: a.url || a.advisory || '',
                 vulnerableVersions: a.vulnerable_versions || a.vulnerableVersions || '',
                 cwe: Array.isArray(a.cwe) ? a.cwe : a.cwe ? [String(a.cwe)] : [],
-                cvssScore: a.cvss && typeof a.cvss.score === 'number' && a.cvss.score > 0 ? a.cvss.score : null,
+                cvssScore: a.cvss && typeof a.cvss.score === 'number' && a.cvss.score > 0
+                    ? a.cvss.score
+                    : null,
                 recommendedVersion: null,
             });
         }
@@ -85,8 +91,14 @@ function parseBunAudit(raw) {
     return issues;
 }
 function semverLevel(current, latest) {
-    const c = String(current).replace(/^[^\d]*/, '').split('.').map((n) => parseInt(n, 10));
-    const l = String(latest).replace(/^[^\d]*/, '').split('.').map((n) => parseInt(n, 10));
+    const c = String(current)
+        .replace(/^[^\d]*/, '')
+        .split('.')
+        .map((n) => parseInt(n, 10));
+    const l = String(latest)
+        .replace(/^[^\d]*/, '')
+        .split('.')
+        .map((n) => parseInt(n, 10));
     if (Number.isNaN(c[0]) || Number.isNaN(l[0]))
         return 'unknown';
     if (l[0] > c[0])
@@ -104,7 +116,10 @@ function parseBunOutdated(raw) {
     for (const line of stripAnsi(raw).split('\n')) {
         if (!line.includes('|'))
             continue;
-        const cells = line.split('|').map((c) => c.trim()).filter((c) => c.length > 0);
+        const cells = line
+            .split('|')
+            .map((c) => c.trim())
+            .filter((c) => c.length > 0);
         if (cells.length !== 4)
             continue;
         const [pkg, current, , latest] = cells;
@@ -115,7 +130,12 @@ function parseBunOutdated(raw) {
         if (seen.has(pkg))
             continue;
         seen.add(pkg);
-        updates.push({ package: pkg, current, latest, level: semverLevel(current, latest) });
+        updates.push({
+            package: pkg,
+            current,
+            latest,
+            level: semverLevel(current, latest),
+        });
     }
     return updates;
 }
@@ -150,7 +170,9 @@ export const pikkuAudit = pikkuSessionlessFunc({
         if (pm === 'bun') {
             try {
                 const issues = parseBunAudit(runBun(['audit', '--json'], root));
-                const updates = includeOutdated ? parseBunOutdated(runBun(['outdated'], root)) : [];
+                const updates = includeOutdated
+                    ? parseBunOutdated(runBun(['outdated'], root))
+                    : [];
                 const latestByPkg = new Map(updates.map((u) => [u.package, u.latest]));
                 for (const i of issues)
                     i.recommendedVersion = latestByPkg.get(i.package) ?? null;
@@ -175,7 +197,9 @@ export const pikkuAudit = pikkuSessionlessFunc({
         else {
             logger.info(`pikku audit — ${summary.totalIssues} advisory(ies)` +
                 ` (${summary.critical} critical, ${summary.high} high, ${summary.moderate} moderate, ${summary.low} low)` +
-                (includeOutdated ? `, ${summary.totalUpdates} available update(s)` : ''));
+                (includeOutdated
+                    ? `, ${summary.totalUpdates} available update(s)`
+                    : ''));
         }
         logger.info(`  → ${outFile}`);
     },

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

@@ -20,7 +20,7 @@ export const bootstrap = pikkuVoidFunc({
         await rpc.invoke('pikkuWorkflow', { bootstrap: true });
         await rpc.invoke('pikkuTriggerTypes', { bootstrap: true });
         await rpc.invoke('pikkuMCPTypes');
-        await rpc.invoke('pikkuAIAgentTypes');
+        await rpc.invoke('pikkuAgentTypes');
         await rpc.invoke('pikkuNodeTypes');
         await rpc.invoke('pikkuSecretDefinitionTypes');
         await rpc.invoke('pikkuScopeDefinitionTypes');

package/dist/src/functions/commands/{dev-ai-runner.d.ts → dev-agent-runner.d.ts}

@@ -1,5 +1,5 @@
 import type { Logger, VariablesService } from '@pikku/core/services';
-import type { AIAgentRunnerService } from '@pikku/core/services';
+import type { AgentRunnerService } from '@pikku/core/services';
 /**
  * Build the AI agent runner for `pikku dev` from env.
  *
@@ -24,8 +24,8 @@ import type { AIAgentRunnerService } from '@pikku/core/services';
  * If it becomes worth it, delegate just `transcription`/`speech` to the full
  * provider and leave everything else on this one.
  */
-export declare function createDevAIAgentRunner({ logger, projectRoot, variables, }: {
+export declare function createDevAgentRunner({ logger, projectRoot, variables, }: {
     logger: Logger;
     projectRoot: string;
     variables: VariablesService;
-}): Promise<AIAgentRunnerService | undefined>;
+}): Promise<AgentRunnerService | undefined>;

package/dist/src/functions/commands/{dev-ai-runner.js → dev-agent-runner.js}

@@ -25,7 +25,7 @@ import { pathToFileURL } from 'url';
  * If it becomes worth it, delegate just `transcription`/`speech` to the full
  * provider and leave everything else on this one.
  */
-export async function createDevAIAgentRunner({ logger, projectRoot, variables, }) {
+export async function createDevAgentRunner({ logger, projectRoot, variables, }) {
     // Pair the URL with its matching key — coalescing each var independently could
     // combine an OPENAI_BASE_URL with a LITELLM_API_KEY (or vice versa) and
     // misroute or 401 every call. Take a complete OpenAI pair first, else LiteLLM.
@@ -68,11 +68,11 @@ export async function createDevAIAgentRunner({ logger, projectRoot, variables, }
             : ['@pikku/ai-vercel', '@ai-sdk/openai-compatible'];
         return Promise.all([import(runner), import(provider)]);
     };
-    let VercelAIAgentRunner;
+    let VercelAgentRunner;
     let createOpenAICompatible;
     try {
         const [runnerModule, providerModule] = await loadPair();
-        ({ VercelAIAgentRunner } = runnerModule);
+        ({ VercelAgentRunner } = runnerModule);
         ({ createOpenAICompatible } = providerModule);
     }
     catch (error) {
@@ -100,5 +100,5 @@ export async function createDevAIAgentRunner({ logger, projectRoot, variables, }
         }),
     });
     logger.info(`pikku dev: AI agent runner wired to ${baseURL}`);
-    return new VercelAIAgentRunner(buildProviders(apiKey), buildProviders);
+    return new VercelAgentRunner(buildProviders(apiKey), buildProviders);
 }

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

@@ -2,12 +2,14 @@ import { join, resolve } from 'path';
 import { existsSync, readFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku';
 import chokidar from 'chokidar';
-import { pikkuDevReloader, reloadGeneratedMeta, reconcileAddonRegistry, } from '@pikku/core/dev';
-import { ConsoleLogger, LocalEmailService, spy, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, InMemoryAIRunStateService, QueueWebhookService, } from '@pikku/core/services';
-import { KyselyAIStorageService, KyselyAIRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
+import { pikkuDevReloader } from '@pikku/core/dev';
+import { reloadGeneratedMeta, reconcileAddonRegistry, } from '@pikku/core/ecosystem/dev';
+import { ConsoleLogger, LocalEmailService, InMemoryQueueService, InMemoryWorkflowService, InMemoryTriggerService, QueueWebhookService, } from '@pikku/core/services';
+import { spy, InMemoryAgentRunStateService, } from '@pikku/core/ecosystem/services';
+import { KyselyAgentStorageService, KyselyAgentRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
 import { stopSingletonServices } from '@pikku/core';
 import { pikkuState } from '@pikku/core/ecosystem';
-import { wireAIScorerQueueWorkers } from '@pikku/core/ai-scorer';
+import { wireAgentScorerQueueWorkers } from '@pikku/core/ecosystem/agent-scorer';
 import { LocalMetaService } from '@pikku/core/services/local-meta';
 import { LocalContent, } from '@pikku/core/services/local-content';
 import { InMemorySchedulerService } from '@pikku/schedule';
@@ -15,7 +17,7 @@ import { resolveDb, createKysely, parseDatabaseUrl, } from '../db/local-db.js';
 import { loadUserBootstrap, loadUserModule } from './load-user-project.js';
 import { registerScenarioInstrumentation } from '../wirings/scenarios/register-scenario-instrumentation.js';
 import { startCoverageService } from './start-coverage.js';
-import { createDevAIAgentRunner } from './dev-ai-runner.js';
+import { createDevAgentRunner } from './dev-agent-runner.js';
 import { resolveConsoleMount } from './serve-console.js';
 import { serverReadyLine } from '../../server/server-ready.js';
 import { createEphemeralContentSigningJWT } from '../../server/content-signing-jwt.js';
@@ -77,11 +79,15 @@ export const dev = pikkuSessionlessFunc({
             // auth requests saw CLI services (no kysely) and crashed.
             const isHotReload = previousSingletonServices !== commandSingletonServices &&
                 !!previousSingletonServices;
+            // Overlaid rather than swapped: swapping left the app reading the CLI's
+            // config for as long as codegen ran.
             const codegenServices = isHotReload
                 ? {
                     ...previousSingletonServices,
-                    config: commandSingletonServices?.config ??
-                        previousSingletonServices.config,
+                    config: {
+                        ...previousSingletonServices.config,
+                        ...commandSingletonServices?.config,
+                    },
                 }
                 : commandSingletonServices;
             pikkuState(null, 'package', 'singletonServices', codegenServices);
@@ -163,19 +169,19 @@ export const dev = pikkuSessionlessFunc({
             ? new LocalContent(localContentConfig, logger, contentSigningJWT)
             : undefined;
         const schedulerService = new InMemorySchedulerService();
-        const aiStorage = kysely
-            ? new KyselyAIStorageService(kysely)
+        const agentStorage = kysely
+            ? new KyselyAgentStorageService(kysely)
             : undefined;
-        const aiRunState = kysely
-            ? new KyselyAIRunStateService(kysely)
-            : new InMemoryAIRunStateService();
+        const agentRunState = kysely
+            ? new KyselyAgentRunStateService(kysely)
+            : new InMemoryAgentRunStateService();
         const agentRunService = kysely
             ? new KyselyAgentRunService(kysely)
             : undefined;
-        if (aiStorage)
-            await aiStorage.init();
-        if ('init' in aiRunState && typeof aiRunState.init === 'function') {
-            await aiRunState.init();
+        if (agentStorage)
+            await agentStorage.init();
+        if ('init' in agentRunState && typeof agentRunState.init === 'function') {
+            await agentRunState.init();
         }
         // InMemoryWorkflowService implements both the workflowService and
         // workflowRunService surfaces (listRuns/getRun live on it). Expose the
@@ -190,8 +196,8 @@ export const dev = pikkuSessionlessFunc({
         // Only when the project declares agents — otherwise the runner's
         // missing-SDK warning fires spuriously for projects with global AI env.
         const hasAgents = Object.keys(inspectorState.agents.agentsMeta).length > 0;
-        const aiAgentRunner = hasAgents
-            ? await createDevAIAgentRunner({
+        const agentRunner = hasAgents
+            ? await createDevAgentRunner({
                 logger,
                 projectRoot: config.rootDir,
                 variables,
@@ -204,7 +210,7 @@ export const dev = pikkuSessionlessFunc({
         const devQueueService = new InMemoryQueueService();
         const inMemoryServices = {
             logger: devLogger,
-            ...(aiAgentRunner ? { aiAgentRunner } : {}),
+            ...(agentRunner ? { agentRunner } : {}),
             emailService: test
                 ? spy('emailService', new LocalEmailService())
                 : new LocalEmailService(),
@@ -216,8 +222,8 @@ export const dev = pikkuSessionlessFunc({
             workflowService,
             workflowRunService: workflowService,
             triggerService: new InMemoryTriggerService(),
-            aiStorage,
-            aiRunState,
+            agentStorage,
+            agentRunState,
             agentRunService,
             eventHub,
             ...(kysely ? { kysely } : {}),
@@ -234,7 +240,7 @@ export const dev = pikkuSessionlessFunc({
         };
         pikkuState(null, 'package', 'singletonServices', resolvedServices);
         resolvedServices.workflowService?.wireQueueWorkers?.();
-        wireAIScorerQueueWorkers();
+        wireAgentScorerQueueWorkers();
         const { serverLifecycleFactory } = inspectorState.filesAndMethods;
         const loadLifecycle = async () => {
             if (!serverLifecycleFactory)
@@ -334,7 +340,7 @@ export const dev = pikkuSessionlessFunc({
                             invalidateInspectorState();
                             await runAllWithCommandState();
                             workflowService.wireQueueWorkers();
-                            wireAIScorerQueueWorkers();
+                            wireAgentScorerQueueWorkers();
                             // Pull the regenerated meta + JSON schemas into the running
                             // process so new/changed functions are callable without a
                             // restart (the hot-reloader registers their implementations).

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

@@ -1,6 +1,6 @@
 import { pikkuSessionlessFunc } from '#pikku';
-import { createHttpPersonas } from '@pikku/core/persona';
-import { personaEnvironmentRefusal } from '@pikku/core/persona';
+import { createHttpPersonas } from '@pikku/core/ecosystem/persona';
+import { personaEnvironmentRefusal } from '@pikku/core/ecosystem/persona';
 import { resolvePersonas } from '../../utils/resolve-personas.js';
 import { resolveEnvironment } from './environment.js';
 import { loadDeclaredRoles, openScopeServiceForRoles } from './roles-shared.js';

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

@@ -1,11 +1,12 @@
 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 { personaVirtualUserTarget, catalogueClassification, DISPOSITIONS, prepareVirtualUserRun, runVirtualUser, } from '@pikku/core/virtual-user';
+import { createHttpPersonas, personaEnvironmentRefusal, roleMismatchMessage, verifyPersonaRoles, } from '@pikku/core/ecosystem/persona';
+import { personaVirtualUserTarget, runVirtualUser, } from '@pikku/core/virtual-user';
+import { catalogueClassification, DISPOSITIONS, prepareVirtualUserRun, } from '@pikku/core/ecosystem/virtual-user';
 import { resolvePersonas } from '../../utils/resolve-personas.js';
 import { resolveEnvironment } from './environment.js';
-import { createDevAIAgentRunner } from './dev-ai-runner.js';
+import { createDevAgentRunner } from './dev-agent-runner.js';
 import { formatVirtualUserReport } from './virtual-user-formatter.js';
 const dispositionNames = Object.keys(DISPOSITIONS);
 /**
@@ -84,12 +85,12 @@ export const personaRun = pikkuSessionlessFunc({
         if (!resolvedModel) {
             throw new Error('No model to think with — pass --model, or set scenarios.model in pikku.config.json.');
         }
-        const aiAgentRunner = await createDevAIAgentRunner({
+        const agentRunner = await createDevAgentRunner({
             logger,
             projectRoot: config.rootDir,
             variables,
         });
-        if (!aiAgentRunner) {
+        if (!agentRunner) {
             throw new Error('No AI provider is configured. Set OPENAI_BASE_URL + OPENAI_API_KEY (or LITELLM_PROXY_URL + LITELLM_API_KEY).');
         }
         // Shared with the scaffolded `runVirtualUser` RPC, which does the same
@@ -153,7 +154,7 @@ export const personaRun = pikkuSessionlessFunc({
                 model: resolvedModel,
                 agents: agents.map((agent) => agent.name),
             }),
-            llm: (params) => aiAgentRunner.run(params),
+            llm: (params) => agentRunner.run(params),
             model: resolvedModel,
             seed: seed ? Number(seed) : undefined,
             allowApprovalRequired: allowApproval ?? false,

package/dist/src/functions/commands/roles-prune.js

@@ -42,7 +42,7 @@ export const rolesPrune = pikkuSessionlessFunc({
             logger.info('');
             logger.info(`roles prune: removed ${pruned.length} system role(s)`);
             if (held.length > 0) {
-                logger.warn(`Revoked from ${affectedUsers} user grant(s). They lose the role's scopes on their next request.`);
+                logger.warn(`Revoked from ${affectedUsers} user grant(s). They lose the role's scopes on their next request — unless mapSession sets scopes itself, in which case it is authoritative and they keep them.`);
             }
         }
         finally {

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

@@ -1,4 +1,4 @@
-import type { SystemRole } from '@pikku/core/role';
+import type { SystemRole } from '@pikku/core/ecosystem/role';
 import { openScopeService } from './scopes-shared.js';
 import type { OpenedScopeService } from './scopes-shared.js';
 type Logger = {

package/dist/src/functions/commands/roles-shared.js

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { flattenSystemRoleDefinitions } from '@pikku/core/role';
+import { flattenSystemRoleDefinitions } from '@pikku/core/ecosystem/role';
 import { loadDeclaredScopes, openScopeService } from './scopes-shared.js';
 const isRoleDefinitionsMeta = (value) => typeof value === 'object' &&
     value !== null &&

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

@@ -7,8 +7,8 @@
  * making the driver's optional isolation and diagnostics safe to call
  * unconditionally.
  */
-import type { ScenarioBrowserFailure, ScenarioBrowserProvider } from '@pikku/core/scenario';
-import type { ResolvedPersona } from '@pikku/core/services';
+import type { ScenarioBrowserFailure, ScenarioBrowserProvider } from '@pikku/core/ecosystem/scenario';
+import type { ResolvedPersona } from '@pikku/core/ecosystem/services';
 /** The default driver, used when a project names no other. */
 export declare const DEFAULT_BROWSER_DRIVER = "@pikku/playwright";
 export interface ScenarioBrowserDriverOptions {

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

@@ -7,7 +7,7 @@
  * second formatter (JSON, JUnit) a matter of writing one function rather than
  * unpicking the runner.
  */
-import type { ScenarioBrowserFailure } from '@pikku/core/scenario';
+import type { ScenarioBrowserFailure } from '@pikku/core/ecosystem/scenario';
 /** The longest gherkin keyword ("Given"), so sentences line up under each other. */
 declare const KEYWORD_WIDTH = 5;
 /** One step of a run, already joined to the prose that declared it. */

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

@@ -1,6 +1,7 @@
-import type { ScenarioStepPhase, ScenarioSurface } from '@pikku/core/scenario';
-import type { WorkflowStepMeta } from '@pikku/core/workflow/types';
-import type { FunctionsMeta } from '@pikku/core';
+import type { ScenarioSurface } from '@pikku/core/scenario';
+import type { ScenarioStepPhase } from '@pikku/core/ecosystem/scenario';
+import type { WorkflowStepMeta } from '@pikku/core/ecosystem/workflow';
+import type { FunctionsMeta } from '@pikku/core/ecosystem/services';
 import type { ScenarioFailureDetail, ScenarioStepRow } from './scenario-formatter.js';
 export interface ScenarioStepProse {
     phase: ScenarioStepPhase;

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

@@ -8,7 +8,7 @@
  * belongs to `scenario-formatter.ts`; this module only decides what each step
  * is called.
  */
-import { composeStepProse } from '@pikku/core/scenario';
+import { composeStepProse } from '@pikku/core/ecosystem/scenario';
 import { KEYWORD_WIDTH } from './scenario-formatter.js';
 /**
  * Walk a workflow's steps — including the ones nested inside branches, fanouts

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

@@ -1,5 +1,5 @@
-import type { CoreWorkflow } from '@pikku/core/workflow';
-import type { CoreFeature } from '@pikku/core/scenario';
+import type { CoreWorkflow } from '@pikku/core/ecosystem/workflow';
+import type { CoreFeature } from '@pikku/core/ecosystem/scenario';
 /** One scenario run: a scenario name and, for a feature's paired entry, its input. */
 export type ScenarioPlanEntry = {
     scenarioName: string;

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

@@ -1,4 +1,4 @@
-import { resolveFeatureScenarios } from '@pikku/core/scenario';
+import { resolveFeatureScenarios } from '@pikku/core/ecosystem/scenario';
 /**
  * Turn the registered scenarios and features into an ordered list of run units.
  *

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

@@ -7,7 +7,6 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     tags?: string;
     excludeTags?: string;
     coverage?: boolean;
-    browser?: boolean;
     run?: ScenarioSurface;
     strict?: boolean;
     spawn?: boolean;
@@ -24,7 +23,6 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     tags?: string;
     excludeTags?: string;
     coverage?: boolean;
-    browser?: boolean;
     run?: ScenarioSurface;
     strict?: boolean;
     spawn?: boolean;
@@ -41,7 +39,6 @@ export declare const scenarioRun: import("#pikku").PikkuFunctionConfig<{
     tags?: string;
     excludeTags?: string;
     coverage?: boolean;
-    browser?: boolean;
     run?: ScenarioSurface;
     strict?: boolean;
     spawn?: boolean;