@pikku/cli 0.12.111 → 0.12.113

package/dist/.pikku/variables/pikku-variables.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.111
+ * This file was generated by @pikku/cli@0.12.113
  */
 import { TypedVariablesService as CoreTypedVariablesService } from '@pikku/core/services';
 import type { VariablesService } from '@pikku/core/services';

package/dist/.pikku/variables/pikku-variables.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.111
+ * This file was generated by @pikku/cli@0.12.113
  */
 import { TypedVariablesService as CoreTypedVariablesService, } from '@pikku/core/services';
 /**

package/dist/.pikku/workflow/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.111
+ * This file was generated by @pikku/cli@0.12.113
  */
 /**
  * Subpath entry — `#pikku/workflow` resolves here.

package/dist/.pikku/workflow/index.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.111
+ * This file was generated by @pikku/cli@0.12.113
  */
 /**
  * Subpath entry — `#pikku/workflow` resolves here.

package/dist/.pikku/workflow/pikku-workflow-types.gen.d.ts

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.111
+ * This file was generated by @pikku/cli@0.12.113
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import type { PikkuWorkflowGraphConfig, PikkuWorkflowGraphResult } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-types.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.111
+ * This file was generated by @pikku/cli@0.12.113
  */
 import { WorkflowCancelledException } from '@pikku/core/workflow';
 import { pikkuWorkflowGraph as corePikkuWorkflowGraph } from '@pikku/core/workflow';

package/dist/.pikku/workflow/pikku-workflow-wirings-meta.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.111
+ * This file was generated by @pikku/cli@0.12.113
  */
 import { pikkuState } from '@pikku/core/state';
 import allWorkflowMeta from './meta/allWorkflow.gen.json' with { type: 'json' };

package/dist/.pikku/workflow/pikku-workflow-wirings.gen.js

@@ -1,5 +1,5 @@
 /**
- * This file was generated by @pikku/cli@0.12.111
+ * This file was generated by @pikku/cli@0.12.113
  */
 import { addWorkflow } from '@pikku/core/workflow';
 import './pikku-workflow-wirings-meta.gen.js';

package/dist/bin/pikku-bin.mjs

@@ -11,8 +11,8 @@ async function checkForUpdate() {
     })
     if (!res.ok) return
     const { version: latest } = await res.json()
-    if (latest !== '0.12.111') {
-      process.stderr.write(`\n  Update available  0.12.111 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
+    if (latest !== '0.12.113') {
+      process.stderr.write(`\n  Update available  0.12.113 → ${latest}\n  brew upgrade pikku  or  npm install -g @pikku/cli\n\n`)
     }
   } catch {}
 }

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

@@ -298,14 +298,12 @@ export const dev = pikkuSessionlessFunc({
             logger.info(`Pikku Console available at http://${hostname}:${resolvedPort}${consoleMount.urlPrefix}`);
         }
         logger.info(serverReadyLine(hostname, resolvedPort));
-        let configWatcher;
         let watcher;
         process.once('SIGINT', async () => {
             logger.info('Stopping dev server...');
             try {
                 await lifecycle?.beforeStop?.(resolvedServices);
                 await stopSingletonServices();
-                await configWatcher?.close();
                 await watcher?.close();
                 await pikkuServer.stop();
                 await lifecycle?.afterStop?.(resolvedServices);
@@ -322,72 +320,84 @@ export const dev = pikkuSessionlessFunc({
             : undefined;
         if (enableWatch) {
             const genIgnore = /\.gen\.tsx?$/;
-            configWatcher = chokidar.watch(watchDirectories, {
+            logger.info(`• Watching directories: \n  - ${watchDirectories.join('\n  - ')}`);
+            watcher = chokidar.watch(watchDirectories, {
                 ignoreInitial: true,
                 ignored: genIgnore,
             });
-            const generatorWatcher = () => {
-                watcher?.close();
-                logger.info(`• Watching directories: \n  - ${watchDirectories.join('\n  - ')}`);
-                watcher = chokidar.watch(watchDirectories, {
-                    ignoreInitial: true,
-                    ignored: genIgnore,
-                });
-                watcher.on('ready', async () => {
-                    const handle = async () => {
+            watcher.on('ready', async () => {
+                const handle = async () => {
+                    try {
+                        const start = Date.now();
+                        invalidateInspectorState();
+                        await runAllWithCommandState();
+                        workflowService.wireQueueWorkers();
+                        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).
+                        await reloadGeneratedMeta({
+                            pikkuDir,
+                            logger,
+                            schemaService: resolvedServices.schema,
+                        });
+                        // Re-import recently changed files now that the fresh meta is
+                        // in state: wire* calls skip routes whose meta doesn't exist,
+                        // so a NEW route in a changed wiring file only registers on
+                        // this post-codegen pass (the reloader's instant pass ran too
+                        // early to see it).
+                        await devReloader?.reimportPending();
+                        // reimportPending only re-runs wire* for changed/added files, so a
+                        // DELETED *.addon.ts leaves its wireAddon entry stranded in the
+                        // live registry. Prune it against the inspection runAllWithCommandState
+                        // already produced this pass — a plain read (no refresh) reuses that
+                        // fresh post-change cache. Forcing refresh=true here re-inspected the
+                        // whole project a SECOND time: the codegen writes after that inspection
+                        // bump the ts-write generation, so refresh treats the cache as stale.
+                        const { rpc } = await getInspectorState();
+                        reconcileAddonRegistry(rpc.wireAddonDeclarations.keys(), logger);
+                        logger.info({
+                            message: `✓ Generated in ${Date.now() - start}ms`,
+                            type: 'timing',
+                        });
+                    }
+                    catch (err) {
+                        logger.error(`Error running watch: ${err}`);
+                    }
+                };
+                // A codegen pass holds a whole ts.Program, so two overlapping passes
+                // double the peak RSS — enough to OOM a sandbox. Coalesce instead:
+                // changes arriving mid-pass schedule exactly one more run after it.
+                let inFlight;
+                let queued = false;
+                const runHandle = async () => {
+                    if (inFlight) {
+                        queued = true;
+                        return;
+                    }
+                    do {
+                        queued = false;
+                        inFlight = handle();
                         try {
-                            const start = Date.now();
-                            invalidateInspectorState();
-                            await runAllWithCommandState();
-                            workflowService.wireQueueWorkers();
-                            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).
-                            await reloadGeneratedMeta({
-                                pikkuDir,
-                                logger,
-                                schemaService: resolvedServices.schema,
-                            });
-                            // Re-import recently changed files now that the fresh meta is
-                            // in state: wire* calls skip routes whose meta doesn't exist,
-                            // so a NEW route in a changed wiring file only registers on
-                            // this post-codegen pass (the reloader's instant pass ran too
-                            // early to see it).
-                            await devReloader?.reimportPending();
-                            // reimportPending only re-runs wire* for changed/added files, so a
-                            // DELETED *.addon.ts leaves its wireAddon entry stranded in the
-                            // live registry. Prune it against the inspection runAllWithCommandState
-                            // already produced this pass — a plain read (no refresh) reuses that
-                            // fresh post-change cache. Forcing refresh=true here re-inspected the
-                            // whole project a SECOND time: the codegen writes after that inspection
-                            // bump the ts-write generation, so refresh treats the cache as stale.
-                            const { rpc } = await getInspectorState();
-                            reconcileAddonRegistry(rpc.wireAddonDeclarations.keys(), logger);
-                            logger.info({
-                                message: `✓ Generated in ${Date.now() - start}ms`,
-                                type: 'timing',
-                            });
+                            await inFlight;
                         }
-                        catch (err) {
-                            logger.error(`Error running watch: ${err}`);
+                        finally {
+                            inFlight = undefined;
                         }
-                    };
-                    await handle();
-                    let timeout;
-                    const deduped = (_file) => {
-                        if (timeout) {
-                            clearTimeout(timeout);
-                        }
-                        timeout = setTimeout(handle, 10);
-                    };
-                    watcher?.on('change', deduped);
-                    watcher?.on('add', deduped);
-                    watcher?.on('unlink', deduped);
-                });
-            };
-            configWatcher.on('ready', generatorWatcher);
-            configWatcher.on('change', generatorWatcher);
+                    } while (queued);
+                };
+                await runHandle();
+                let timeout;
+                const deduped = (_file) => {
+                    if (timeout) {
+                        clearTimeout(timeout);
+                    }
+                    timeout = setTimeout(runHandle, 10);
+                };
+                watcher?.on('change', deduped);
+                watcher?.on('add', deduped);
+                watcher?.on('unlink', deduped);
+            });
         }
         await new Promise(() => { });
     },

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

@@ -3,6 +3,7 @@ import { mkdirSync, writeFileSync } from 'node:fs';
 import { pikkuSessionlessFunc } from '#pikku/function';
 import { createHttpPersonas, personaEnvironmentRefusal, roleMismatchMessage, verifyPersonaRoles, } from '@pikku/core/persona';
 import { personaVirtualUserTarget, runVirtualUser, catalogueClassification, DISPOSITIONS, prepareVirtualUserRun, } from '@pikku/core/virtual-user';
+import { getSingletonServices, setSingletonServices } from '@pikku/core/state';
 import { resolvePersonas } from '../../utils/resolve-personas.js';
 import { resolveEnvironment } from './environment.js';
 import { createDevAgentRunner } from './dev-agent-runner.js';
@@ -92,6 +93,11 @@ export const personaRun = pikkuSessionlessFunc({
         if (!agentRunner) {
             throw new Error('No AI provider is configured. Set OPENAI_BASE_URL + OPENAI_API_KEY (or LITELLM_PROXY_URL + LITELLM_API_KEY).');
         }
+        // `talkTo` reaches the runner through the singleton registry rather than
+        // through the `llm` handed to the engine, so a persona offered an agent
+        // dies on its first word without this — and only for a persona whose
+        // scopes reach one, which is why it survives a run as anybody else.
+        setSingletonServices({ ...getSingletonServices(), agentRunner });
         // Shared with the scaffolded `runVirtualUser` RPC, which does the same
         // derivation from `metaService` at runtime — the two have to agree, or the
         // same persona and seed explore a different API depending on how it was

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

@@ -13,48 +13,67 @@ export const watch = pikkuSessionlessFunc({
                 logger,
             });
         }
-        const configWatcher = chokidar.watch(watchDirectories, {
+        const watcher = chokidar.watch(watchDirectories, {
             ignoreInitial: true,
             ignored: /.*\.gen\.tsx?/,
         });
-        let watcher = new chokidar.FSWatcher({});
-        const generatorWatcher = () => {
-            watcher.close();
-            logger.info(`• Watching directories: \n  - ${watchDirectories.join('\n  - ')}`);
-            watcher = chokidar.watch(watchDirectories, {
-                ignoreInitial: true,
-                ignored: /.*\.gen\.ts/,
-            });
-            watcher.on('ready', async () => {
-                const handle = async () => {
+        logger.info(`• Watching directories: \n  - ${watchDirectories.join('\n  - ')}`);
+        watcher.on('ready', async () => {
+            const handle = async () => {
+                try {
+                    const start = Date.now();
+                    invalidateInspectorState();
+                    await rpc.invoke('all');
+                    logger.info({
+                        message: `✓ Generated in ${Date.now() - start}ms`,
+                        type: 'timing',
+                    });
+                }
+                catch (err) {
+                    console.error(err);
+                    logger.error('Error running watch');
+                }
+            };
+            // A codegen pass holds a whole ts.Program, so two overlapping passes double
+            // the peak RSS. Coalesce instead: changes arriving mid-pass schedule exactly
+            // one more run after it.
+            let inFlight;
+            let queued = false;
+            const runHandle = async () => {
+                if (inFlight) {
+                    queued = true;
+                    return;
+                }
+                do {
+                    queued = false;
+                    inFlight = handle();
                     try {
-                        const start = Date.now();
-                        invalidateInspectorState();
-                        await rpc.invoke('all');
-                        logger.info({
-                            message: `✓ Generated in ${Date.now() - start}ms`,
-                            type: 'timing',
-                        });
-                    }
-                    catch (err) {
-                        console.error(err);
-                        logger.error('Error running watch');
+                        await inFlight;
                     }
-                };
-                await handle();
-                let timeout;
-                const deduped = (_file) => {
-                    if (timeout) {
-                        clearTimeout(timeout);
+                    finally {
+                        inFlight = undefined;
                     }
-                    timeout = setTimeout(handle, 1000);
-                };
-                watcher.on('change', deduped);
-                watcher.on('add', deduped);
-                watcher.on('unlink', deduped);
-            });
-        };
-        configWatcher.on('ready', generatorWatcher);
-        configWatcher.on('change', generatorWatcher);
+                } while (queued);
+            };
+            await runHandle();
+            let timeout;
+            const deduped = (_file) => {
+                if (timeout) {
+                    clearTimeout(timeout);
+                }
+                timeout = setTimeout(runHandle, 1000);
+            };
+            watcher.on('change', deduped);
+            watcher.on('add', deduped);
+            watcher.on('unlink', deduped);
+        });
+        process.once('SIGINT', async () => {
+            await watcher.close();
+            process.exit(0);
+        });
+        // Without this the command returns the moment the handlers are registered and
+        // the process exits, taking the watcher with it — chokidar's `ready` never
+        // fires, so `pikku watch` regenerated nothing at all.
+        await new Promise(() => { });
     },
 });