@pikku/cli 0.12.104 → 0.12.107

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

@@ -1,22 +1,21 @@
 import { randomUUID } from 'node:crypto';
 import { resolve, join } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { InMemoryWorkflowService } from '@pikku/core/services';
+import { FileScenarioRunStore } from '@pikku/core/services';
 import { createHttpPersonas } from '@pikku/core/persona';
-import { PikkuScenarioService } from '@pikku/core/scenario';
-import { pikkuState, getAllPackageStates } from '@pikku/core/ecosystem';
-import { resolveFeatureScenarios } from '@pikku/core/scenario';
+import { PikkuScenarioService, resolveFeatureScenarios, SCENARIO_SURFACES, } from '@pikku/core/scenario';
+import { pikkuState, getAllPackageStates } from '@pikku/core/state';
 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 { 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 +87,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 = 'failed', apiUrl, appUrl, }) => {
         if (!SCENARIO_SURFACES.includes(runSurface)) {
             throw new Error(`Unknown --run surface '${runSurface}'. Expected one of: ${SCENARIO_SURFACES.join(', ')}.`);
         }
@@ -191,49 +190,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 +236,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 +247,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,30 +277,32 @@ 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
-        // is one folder to open, keep or delete. `--video` implies capture is on:
-        // recording without somewhere to put it is not a thing anyone wants.
+        // is one folder to open, keep or delete.
         const captureDir = join(resolve(config.rootDir, config.outDir), 'scenario-runs');
         // One id for the whole invocation, distinct from a scenario's own runId:
         // reviewing artifacts means opening what `pikku scenario run` just produced,
         // not hunting for one scenario's folder among many.
         const captureRunId = randomUUID();
-        const capture = screenshots || video
-            ? { dir: captureDir, runId: captureRunId, video, compress: true }
-            : undefined;
+        const capture = {
+            dir: captureDir,
+            runId: captureRunId,
+            screenshots,
+            video,
+            compress: true,
+        };
         const browserLifecycle = scenarioBrowserLifecycle(needsBrowser
             ? await (async () => {
                 const provider = await resolveScenarioBrowserProvider({
                     environment,
                     apiUrl: env.apiUrl,
                     appUrl: env.appUrl,
+                    appUrls: env.appUrls,
                     secret,
                     actors: scenarioActors,
                     signInPath: env.signInPath,
-                    failureDir,
                     capture,
                     browserScenarios: [...browserStepsByFlow.keys()],
                     driver: config.scenarios?.browserDriver,
@@ -316,6 +312,21 @@ export const scenarioRun = pikkuSessionlessFunc({
             })()
             : undefined);
         const results = [];
+        // Opened before the first scenario and written to as each one finishes, so
+        // a suite that dies on its fortieth still leaves the thirty-nine behind —
+        // and the console can show a run while it is still going.
+        const runStore = new FileScenarioRunStore({ dir: captureDir });
+        const startedAtIso = new Date().toISOString();
+        await runStore.start({
+            runId: captureRunId,
+            environment,
+            surface: runSurface,
+            status: 'running',
+            startedAt: startedAtIso,
+            results: [],
+            skipped,
+            hookFailures: [],
+        });
         /**
          * The step ladder is read back off the recorded run, so it needs no live
          * step events — it is the same data the console renders. Joining it to the
@@ -378,7 +389,22 @@ export const scenarioRun = pikkuSessionlessFunc({
             });
         };
         const hookFailures = [];
-        const runEntry = async (label, scenarioName, data) => {
+        /**
+         * What a result carries beyond its own outcome: which registration ran,
+         * which feature grouped it, and the tags it was selected by. Snapshotted
+         * into the record because a run read back next week is describing a suite
+         * whose source has moved on.
+         */
+        const identify = (result, scenarioName, feature) => {
+            const tags = state.workflows?.meta?.[scenarioName]?.tags;
+            return {
+                ...result,
+                scenarioName,
+                ...(feature ? { feature } : {}),
+                ...(tags?.length ? { tags } : {}),
+            };
+        };
+        const runEntry = async (label, scenarioName, data, feature) => {
             const startedAt = Date.now();
             // Before the scenario, not after it: the last scenario's window is left
             // open for headed debugging, while this one still starts clean.
@@ -452,6 +478,11 @@ export const scenarioRun = pikkuSessionlessFunc({
                     browser: await browserLifecycle.captureFailure(label),
                 };
             }
+            // Told here, acted on at the next scenario's reset — that is what closes
+            // these windows and finalises the video this outcome decides the fate of.
+            browserLifecycle.endScenario(result.status);
+            Object.assign(result, identify(result, scenarioName, feature));
+            await runStore.recordScenario(captureRunId, result);
             if (coverageActive) {
                 const report = await invokeCoverage('pikkuScenarioTakeLiveCoverage');
                 if (report) {
@@ -484,17 +515,19 @@ export const scenarioRun = pikkuSessionlessFunc({
                     // Setup failed, so nothing in the group ran. Reporting them as failed
                     // rather than skipped is the honest reading: they did not pass.
                     for (const entry of group.entries) {
-                        results.push({
+                        const result = identify({
                             name: label(entry),
                             status: 'failed',
                             durationMs: 0,
                             error: `feature '${groupName}' before hook failed: ${beforeError?.message ?? beforeError}`,
-                        });
+                        }, entry.scenarioName, groupName);
+                        results.push(result);
+                        await runStore.recordScenario(captureRunId, result);
                     }
                 }
                 else {
                     for (const entry of group.entries) {
-                        await runEntry(label(entry), entry.scenarioName, entry.data);
+                        await runEntry(label(entry), entry.scenarioName, entry.data, groupName);
                     }
                 }
             }
@@ -510,10 +543,23 @@ export const scenarioRun = pikkuSessionlessFunc({
             }
         }
         await browserLifecycle.close();
-        // Reported after the browser has closed, because video is only finalised
-        // when its context is. A capture nobody can find is a capture nobody
-        // looks at, and looking at them is the entire point of the flags.
-        if (capture) {
+        // Collected after the browser has closed, because a video is only finalised
+        // when its context is — and renamed again by the encode that close() runs.
+        // This is the first moment the answer is complete.
+        const artifacts = browserLifecycle.artifacts();
+        await runStore.attachArtifacts(captureRunId, artifacts);
+        const failed = results.filter((r) => r.status === 'failed');
+        await runStore.finish(captureRunId, {
+            status: failed.length > 0 || hookFailures.length > 0 ? 'failed' : 'passed',
+            finishedAt: new Date().toISOString(),
+            skipped,
+            hookFailures,
+        });
+        // A capture nobody can find is a capture nobody looks at, and looking at
+        // them is the entire point of the flags. Announced only when the run
+        // actually filed something: every run leaves a record behind, and most of
+        // them have no images or footage to go with it.
+        if (artifacts.length > 0) {
             logger.info(`Captures → ${join(capture.dir, capture.runId)}`);
         }
         if (coverage && Object.keys(scenarioCoverage).length > 0) {
@@ -542,14 +588,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 +604,15 @@ export const scenarioRun = pikkuSessionlessFunc({
                 write(`${line} — asserted server-side only: ${[...unwitnessed].join(', ')}`);
             }
         }
-        const failed = results.filter((r) => r.status === 'failed');
+        // 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.`);
+        }
         if (failed.length > 0 ||
             hookFailures.length > 0 ||
+            unrunnable.length > 0 ||
             (strict && unwitnessed.size > 0)) {
             process.exitCode = 1;
         }

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, unknown> | import("#pikku").PikkuFunction<{}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+export declare const scopesAudit: import("#pikku/function").PikkuFunctionConfig<{}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { loadDeclaredScopes, openScopeService, reportStaleScopes, } from './scopes-shared.js';
 export const scopesAudit = pikkuSessionlessFunc({
     remote: true,

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

@@ -5,10 +5,10 @@
  * This revokes access, so it never runs implicitly — not at boot, not as part
  * of `pikku all`. Without `--yes` it only reports the blast radius.
  */
-export declare const scopesPrune: import("#pikku").PikkuFunctionConfig<{
+export declare const scopesPrune: import("#pikku/function").PikkuFunctionConfig<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     yes?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,4 +1,4 @@
-import { pikkuSessionlessFunc } from '#pikku';
+import { pikkuSessionlessFunc } from '#pikku/function';
 import { loadDeclaredScopes, openScopeService, reportStaleScopes, } from './scopes-shared.js';
 /**
  * Removes scopes that are no longer declared in code, cascading them out of

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;

package/dist/src/functions/commands/semver-render.js

@@ -0,0 +1,60 @@
+import { added, changed, dim, removed, table } from '../../fabric/lib/output.js';
+const STATUS_COLOUR = {
+    added,
+    removed,
+    modified: changed,
+};
+const verdictColour = (verdict) => verdict === 'major'
+    ? removed(verdict)
+    : verdict === 'minor'
+        ? changed(verdict)
+        : dim(verdict);
+export const renderSemver = (_services, result) => {
+    if (result.mode === 'emit') {
+        // No `--out`: the snapshot itself is the output, so it can be redirected.
+        if (!result.written) {
+            console.log(JSON.stringify(result.surface));
+            return;
+        }
+        const counts = [
+            `${Object.keys(result.surface.functions).length} functions`,
+            `${Object.keys(result.surface.schemas).length} schemas`,
+        ].join(', ');
+        console.log(`Surface snapshot written to ${result.written}  ${dim(counts)}`);
+        return;
+    }
+    const lines = [''];
+    if (result.changes.length === 0) {
+        lines.push(`${verdictColour('patch')}  no surface change against ${result.baseline}`, dim('   only internals moved'), '');
+        lines.push(dim(`   written to ${result.written}`));
+        console.log(lines.join('\n'));
+        return;
+    }
+    const rows = result.changes.map((change) => [
+        change.breaking ? removed('breaking') : dim('compatible'),
+        change.kind,
+        STATUS_COLOUR[change.status](change.status),
+        change.id,
+        change.reasons[0] ?? '',
+    ]);
+    lines.push(table(['', 'Kind', 'Status', 'Id', 'Reason'], rows));
+    // Only the first reason fits the table; a function whose schema moved in
+    // several ways gets the rest listed underneath so nothing is lost to layout.
+    for (const change of result.changes) {
+        if (change.reasons.length <= 1)
+            continue;
+        lines.push('', `${change.kind} ${change.id}`);
+        for (const reason of change.reasons) {
+            lines.push(dim(`   ${reason}`));
+        }
+    }
+    const { breaking, added: addedCount, removed: removedCount, modified, } = result.summary;
+    const summary = [
+        `${breaking} breaking`,
+        `${addedCount} added`,
+        `${removedCount} removed`,
+        `${modified} modified`,
+    ].join('  ');
+    lines.push('', '─'.repeat(40), `${verdictColour(result.verdict)} against ${result.baseline}`, dim(`   ${summary}`), dim(`   written to ${result.written}`));
+    console.log(lines.join('\n'));
+};

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

@@ -0,0 +1,25 @@
+import { type Surface } from '../../utils/surface.js';
+import { type SurfaceChanges } from '../../utils/surface-diff.js';
+/**
+ * `pikku semver` — what does this build owe the clients of another one?
+ *
+ * The baseline is deliberately external: a deployed environment, not the
+ * previous commit. Comparing against production is what makes the answer
+ * actionable, and pointing `--against` somewhere else is how you ask the same
+ * question about staging.
+ */
+export type SemverInput = {
+    against?: string;
+    emit?: boolean;
+    out?: string;
+    failOn?: string;
+};
+export type SemverResult = {
+    mode: 'emit';
+    surface: Surface;
+    written: string | null;
+} | ({
+    mode: 'compare';
+    written: string;
+} & SurfaceChanges);
+export declare const pikkuSemver: import("#pikku/function").PikkuFunctionConfig<SemverInput, SemverResult, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<SemverInput, SemverResult, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<SemverInput, SemverResult, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -0,0 +1,50 @@
+import { mkdirSync, writeFileSync } from 'fs';
+import { dirname, join, resolve } from 'path';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { loadManifest } from '../../utils/contract-versions.js';
+import { loadSurface, readSurface } from '../../utils/surface.js';
+import { computeSurfaceDiff, } from '../../utils/surface-diff.js';
+const FAIL_LEVELS = ['major', 'minor', 'patch'];
+// Ordered by severity, so `--fail-on minor` also fails on major.
+const SEVERITY = { patch: 0, minor: 1, major: 2 };
+async function currentSurface(rootDir, outDir) {
+    const manifest = await loadManifest(join(rootDir, 'versions.pikku.json'));
+    return readSurface(outDir, manifest);
+}
+function writeJson(path, value) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify(value, null, 2) + '\n', 'utf-8');
+}
+export const pikkuSemver = pikkuSessionlessFunc({
+    func: async ({ config }, input) => {
+        const outDir = resolve(config.rootDir, config.outDir);
+        const out = input?.out ? resolve(config.rootDir, input.out) : null;
+        if (input?.emit === true) {
+            const surface = await currentSurface(config.rootDir, outDir);
+            if (out)
+                writeJson(out, surface);
+            return { mode: 'emit', surface, written: out };
+        }
+        const against = input?.against;
+        if (!against) {
+            throw new Error("Nothing to compare against. Pass `--against <path|url>` — a `.pikku` directory, a snapshot file, or a snapshot URL — or `--emit` to produce this build's snapshot.");
+        }
+        const [before, after] = await Promise.all([
+            loadSurface(against),
+            currentSurface(config.rootDir, outDir),
+        ]);
+        const changes = computeSurfaceDiff(before, after, against);
+        const changesPath = out ?? join(outDir, 'changes.gen.json');
+        writeJson(changesPath, changes);
+        const failOn = input?.failOn;
+        if (failOn) {
+            if (!FAIL_LEVELS.includes(failOn)) {
+                throw new Error(`--fail-on must be one of ${FAIL_LEVELS.join(', ')}, got '${failOn}'.`);
+            }
+            if (SEVERITY[changes.verdict] >= SEVERITY[failOn]) {
+                throw new Error(`Release is ${changes.verdict} against ${against}, at or above --fail-on ${failOn}. See ${changesPath}.`);
+            }
+        }
+        return { mode: 'compare', written: changesPath, ...changes };
+    },
+});

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

@@ -1,13 +1,13 @@
-export declare const serve: import("#pikku").PikkuFunctionConfig<{
+export declare const serve: import("#pikku/function").PikkuFunctionConfig<{
     port?: string;
     console?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     port?: string;
     console?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     port?: string;
     console?: boolean;
     model?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;

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

@@ -1,10 +1,13 @@
 import { join, resolve } from 'path';
-import { pikkuSessionlessFunc } from '#pikku';
-import { ConsoleLogger, LocalEmailService, 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/ecosystem';
-import { wireAIScorerQueueWorkers } from '@pikku/core/ai-scorer';
+import { pikkuSessionlessFunc } from '#pikku/function';
+import { InMemoryQueueService, QueueWebhookService } from '@pikku/core/services';
+import { ConsoleLogger, LocalEmailService, InMemoryAgentRunStateService, } from '@pikku/core/services';
+import { InMemoryTriggerService } from '@pikku/core/services';
+import { InMemoryWorkflowService } from '@pikku/core/services';
+import { KyselyAgentStorageService, KyselyAgentRunStateService, KyselyAgentRunService, } from '@pikku/kysely';
+import { stopSingletonServices } from '@pikku/core/utils';
+import { pikkuState } from '@pikku/core/state';
+import { wireAgentScorerQueueWorkers } from '@pikku/core/agent-scorer';
 import { LocalMetaService } from '@pikku/core/services/local-meta';
 import { LocalContent, } from '@pikku/core/services/local-content';
 import { InMemorySchedulerService } from '@pikku/schedule';
@@ -12,7 +15,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 { resolveScaffoldFeature } from '../../utils/resolve-scaffold-feature.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';
@@ -75,24 +78,24 @@ export const serve = 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();
         }
         const devLogger = new ConsoleLogger();
         const hasAgents = Object.keys(inspectorState.agents.agentsMeta).length > 0;
-        const aiAgentRunner = hasAgents
-            ? await createDevAIAgentRunner({
+        const agentRunner = hasAgents
+            ? await createDevAgentRunner({
                 logger,
                 projectRoot: config.rootDir,
                 variables,
@@ -102,7 +105,7 @@ export const serve = pikkuSessionlessFunc({
         const serveQueueService = new InMemoryQueueService();
         const inMemoryServices = {
             logger: devLogger,
-            ...(aiAgentRunner ? { aiAgentRunner } : {}),
+            ...(agentRunner ? { agentRunner } : {}),
             emailService: new LocalEmailService(),
             metaService: new LocalMetaService(pikkuDir),
             schedulerService,
@@ -111,8 +114,8 @@ export const serve = pikkuSessionlessFunc({
             workflowService,
             workflowRunService: workflowService,
             triggerService: new InMemoryTriggerService(),
-            aiStorage,
-            aiRunState,
+            agentStorage,
+            agentRunState,
             agentRunService,
             eventHub,
             ...(kysely ? { kysely } : {}),
@@ -128,7 +131,7 @@ export const serve = pikkuSessionlessFunc({
         };
         pikkuState(null, 'package', 'singletonServices', resolvedServices);
         resolvedServices.workflowService?.wireQueueWorkers?.();
-        wireAIScorerQueueWorkers();
+        wireAgentScorerQueueWorkers();
         const { serverLifecycleFactory } = inspectorState.filesAndMethods;
         const loadLifecycle = async () => {
             if (!serverLifecycleFactory)

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

@@ -1,26 +1,26 @@
-export declare const pikkuSkillsList: import("#pikku").PikkuFunctionConfig<{
+export declare const pikkuSkillsList: import("#pikku/function").PikkuFunctionConfig<{
     target?: string;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     target?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     target?: string;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
-export declare const pikkuSkillsInstall: import("#pikku").PikkuFunctionConfig<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;
+export declare const pikkuSkillsInstall: import("#pikku/function").PikkuFunctionConfig<{
     agent?: string;
     only?: string;
     core?: boolean;
     fabric?: boolean;
     update?: boolean;
-}, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<{
+}, void, "rpc" | "session", import("#pikku/function").PikkuFunctionSessionless<{
     agent?: string;
     only?: string;
     core?: boolean;
     fabric?: boolean;
     update?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices, unknown> | import("#pikku").PikkuFunction<{
+}, void, "rpc" | "session", import("#pikku/function").WiredServices, unknown> | import("#pikku/function").PikkuFunction<{
     agent?: string;
     only?: string;
     core?: boolean;
     fabric?: boolean;
     update?: boolean;
-}, void, "rpc" | "session", import("#pikku").WiredServices>, undefined, undefined>;
+}, void, "rpc" | "session", import("#pikku/function").WiredServices>, undefined, undefined>;