@pikku/cli 0.12.104 → 0.12.105

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-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;

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

@@ -3,20 +3,20 @@ import { resolve, join } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku';
 import { InMemoryWorkflowService } from '@pikku/core/services';
-import { createHttpPersonas } from '@pikku/core/persona';
-import { PikkuScenarioService } from '@pikku/core/scenario';
+import { createHttpPersonas } from '@pikku/core/ecosystem/persona';
+import { PikkuScenarioService } from '@pikku/core/ecosystem/scenario';
 import { pikkuState, getAllPackageStates } from '@pikku/core/ecosystem';
-import { resolveFeatureScenarios } from '@pikku/core/scenario';
+import { resolveFeatureScenarios } from '@pikku/core/ecosystem/scenario';
 import { loadScenarioBootstrap } from './load-user-project.js';
 import { collectScenarioStepProse, scenarioBrowserSteps, scenarioFailureFromSteps, scenarioStepRows, scenarioStepsWithoutBinding, scenarioSurfaceCoverage, } from './scenario-ladder.js';
-import { SCENARIO_SURFACES } from '@pikku/core/scenario';
+import { SCENARIO_SURFACES } from '@pikku/core/ecosystem/scenario';
 import { formatScenarioReport } from './scenario-formatter.js';
 import { resolveScenarioBrowserProvider, scenarioBrowserLifecycle, } from './scenario-browser.js';
 import { resolvePersonas } from '../../utils/resolve-personas.js';
 import { spawnDevServer } from '../../server/spawn-dev-server.js';
 import { buildScenarioPlan } from './scenario-plan.js';
 import { resolveEnvironment } from './environment.js';
-import { createDevAIAgentRunner } from './dev-ai-runner.js';
+import { createDevAgentRunner } from './dev-agent-runner.js';
 const isScenario = (wf) => wf?.scenario === true;
 const listScenarios = (state) => Object.entries(state.workflows?.meta ?? {})
     .filter(([, wf]) => isScenario(wf))
@@ -88,7 +88,7 @@ export const scenarioList = pikkuSessionlessFunc({
     },
 });
 export const scenarioRun = pikkuSessionlessFunc({
-    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, features, tags, excludeTags, coverage, browser = true, run: runSurface = 'default', strict = false, spawn = false, keepAlive = false, trace = false, screenshots = false, video = false, apiUrl, appUrl, }) => {
+    func: async ({ logger, config, getInspectorState, variables }, { environment, flows, features, tags, excludeTags, coverage, run: runSurface = 'default', strict = false, spawn = false, keepAlive = false, trace = false, screenshots = false, video = false, apiUrl, appUrl, }) => {
         if (!SCENARIO_SURFACES.includes(runSurface)) {
             throw new Error(`Unknown --run surface '${runSurface}'. Expected one of: ${SCENARIO_SURFACES.join(', ')}.`);
         }
@@ -191,49 +191,44 @@ export const scenarioRun = pikkuSessionlessFunc({
             scenarioBrowserSteps(state.workflows?.meta?.[name], functionsMeta),
         ])
             .filter(([, steps]) => steps.length > 0));
-        // `--no-browser` is the blunt form of `--run default`: a machine with no
-        // browser takes the server-side path rather than skipping the scenario.
-        const effectiveSurface = browser === false && runSurface === 'browser' ? 'default' : runSurface;
         const unrunnableStepsByFlow = new Map([...scenarioNames]
             .map((name) => [
             name,
-            scenarioStepsWithoutBinding(state.workflows?.meta?.[name], functionsMeta, effectiveSurface),
+            scenarioStepsWithoutBinding(state.workflows?.meta?.[name], functionsMeta, runSurface),
         ])
             .filter(([, steps]) => steps.length > 0));
-        // Two reasons a scenario is held back, both reported as SKIP rather than
-        // failed. `--no-browser` is the direct replacement for cucumber's `@console`
-        // tag, so a standard run stays green on a machine with no browser; a `skip`
-        // on the scenario itself is the project quarantining it, and the plan has
-        // already cleared that reason for anything named directly with `--flows`.
-        const skipReasonFor = (entry) => {
-            if (entry.skip)
-                return entry.skip;
-            const unrunnable = unrunnableStepsByFlow.get(entry.scenarioName);
-            if (unrunnable?.length) {
-                return `no ${effectiveSurface} or default binding: ${unrunnable.join(', ')}`;
-            }
-            return undefined;
-        };
-        const skipped = [];
+        // A `skip` is the project quarantining a scenario on purpose and stays
+        // green; no binding for the run surface is a misconfigured run and fails.
+        const quarantined = [];
+        const unrunnable = [];
         groups = groups
             .map((group) => ({
             ...group,
             entries: group.entries.filter((entry) => {
-                const reason = skipReasonFor(entry);
-                if (!reason)
-                    return true;
-                skipped.push({ name: entry.scenarioName, reason });
-                return false;
+                if (entry.skip) {
+                    quarantined.push({ name: entry.scenarioName, reason: entry.skip });
+                    return false;
+                }
+                const steps = unrunnableStepsByFlow.get(entry.scenarioName);
+                if (steps?.length) {
+                    unrunnable.push({
+                        name: entry.scenarioName,
+                        reason: `no ${runSurface} or default binding: ${steps.join(', ')}`,
+                    });
+                    return false;
+                }
+                return true;
             }),
         }))
             .filter((group) => group.entries.length > 0);
+        const skipped = [...quarantined, ...unrunnable];
         const workflowService = new InMemoryWorkflowService();
         const scenarioService = workflowService.setRunExtension((engine) => new PikkuScenarioService(engine));
         scenarioService.setScenarioEnvironment({
             apiUrl: env.apiUrl,
             appUrl: env.appUrl,
         });
-        scenarioService.setRunSurface(effectiveSurface);
+        scenarioService.setRunSurface(runSurface);
         // Scenario steps run here, not on the target — everything they touch of the
         // app goes over HTTP through an actor, which is what `guardRpc` below
         // enforces. `actor.converse` is the exception, and the reason this is not
@@ -242,8 +237,8 @@ export const scenarioRun = pikkuSessionlessFunc({
         // before it says anything. Built the same way `pikku dev` builds its own,
         // and only when the project declares agents, so a project with no agents
         // does not have to have AI env set to run scenarios.
-        const aiAgentRunner = Object.keys(state.agents?.agentsMeta ?? {}).length > 0
-            ? await createDevAIAgentRunner({
+        const agentRunner = Object.keys(state.agents?.agentsMeta ?? {}).length > 0
+            ? await createDevAgentRunner({
                 logger,
                 projectRoot: config.rootDir,
                 variables,
@@ -253,7 +248,7 @@ export const scenarioRun = pikkuSessionlessFunc({
             logger,
             workflowService,
             workflowRunService: workflowService,
-            ...(aiAgentRunner ? { aiAgentRunner } : {}),
+            ...(agentRunner ? { agentRunner } : {}),
         });
         const refuseInternal = (rpcName) => {
             throw new Error(`Scenario tried to run '${rpcName}' as an internal step. Every workflow.do ` +
@@ -283,7 +278,7 @@ export const scenarioRun = pikkuSessionlessFunc({
         // Only a browser run launches one. Under `--run default` a step with a
         // browser binding takes its default path instead, so there is nothing to
         // drive and nothing to pay for.
-        const needsBrowser = effectiveSurface === 'browser' &&
+        const needsBrowser = runSurface === 'browser' &&
             groups.some((group) => group.entries.some((entry) => browserStepsByFlow.has(entry.scenarioName)));
         const failureDir = join(resolve(config.rootDir, config.outDir), 'scenario-failures');
         // Artifacts are filed under the run, not the scenario, so one run's output
@@ -542,14 +537,14 @@ export const scenarioRun = pikkuSessionlessFunc({
         const surfaceCoverage = { onSurface: 0, total: 0 };
         const unwitnessed = new Set();
         for (const name of scenarioNames) {
-            const scenario = scenarioSurfaceCoverage(state.workflows?.meta?.[name], functionsMeta, effectiveSurface);
+            const scenario = scenarioSurfaceCoverage(state.workflows?.meta?.[name], functionsMeta, runSurface);
             surfaceCoverage.onSurface += scenario.onSurface;
             surfaceCoverage.total += scenario.total;
             for (const step of scenario.unwitnessed)
                 unwitnessed.add(step);
         }
-        if (effectiveSurface !== 'default' && surfaceCoverage.total > 0) {
-            const line = `${surfaceCoverage.onSurface}/${surfaceCoverage.total} steps ran on ${effectiveSurface}`;
+        if (runSurface !== 'default' && surfaceCoverage.total > 0) {
+            const line = `${surfaceCoverage.onSurface}/${surfaceCoverage.total} steps ran on ${runSurface}`;
             if (unwitnessed.size === 0) {
                 logger.info(line);
             }
@@ -558,9 +553,16 @@ export const scenarioRun = pikkuSessionlessFunc({
                 write(`${line} — asserted server-side only: ${[...unwitnessed].join(', ')}`);
             }
         }
+        // Exiting 0 here makes "62 held back" and "62 passed" indistinguishable
+        // to CI, which is how a whole browser suite went unrun.
+        if (unrunnable.length > 0) {
+            logger.error(`${unrunnable.length} scenario(s) could not run on '${runSurface}' — no binding for that surface and no default to fall back to. ` +
+                `Run them on the surface they are written for (--run browser), or hold them back explicitly with --exclude-tags.`);
+        }
         const failed = results.filter((r) => r.status === 'failed');
         if (failed.length > 0 ||
             hookFailures.length > 0 ||
+            unrunnable.length > 0 ||
             (strict && unwitnessed.size > 0)) {
             process.exitCode = 1;
         }

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

@@ -1,5 +1,5 @@
 import type { Kysely } from 'kysely';
-import type { FlatScope } from '@pikku/core/scope';
+import type { FlatScope } from '@pikku/core/ecosystem/scope';
 import { KyselyScopeService } from '@pikku/kysely';
 import type { KyselyPikkuDB } from '@pikku/kysely';
 type Logger = {

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

@@ -1,5 +1,5 @@
 import { readFile } from 'node:fs/promises';
-import { flattenScopeDefinitions } from '@pikku/core/scope';
+import { flattenScopeDefinitions } from '@pikku/core/ecosystem/scope';
 import { KyselyScopeService } from '@pikku/kysely';
 import { createKysely, resolveDb } from '../db/local-db.js';
 import { loadUserConfigForDb } from './db-shared.js';

package/dist/src/functions/commands/semver-render.d.ts

@@ -0,0 +1,2 @@
+import type { SemverResult } from './semver.js';
+export declare const renderSemver: (_services: unknown, result: SemverResult) => void;