@promptbook/cli 0.114.0-5 → 0.114.0-7

package/agents/default/developer.book

@@ -2,6 +2,7 @@ Developer
 
 
 
+META VISUAL ascii-octopus
 META VISIBILITY PRIVATE
 
 RULE

package/apps/agents-server/next.config.ts

@@ -34,6 +34,15 @@ const AGENTS_SERVER_BUILD_WORKER_COUNT = parseAgentsServerBuildWorkerCount(
     process.env.PTBK_AGENTS_SERVER_BUILD_WORKER_COUNT,
 );
 
+/**
+ * Whether this build has to stay inside a small memory budget.
+ *
+ * Standalone VPS self-updates request a single build worker because they compile the replacement
+ * server while the current one is still serving traffic, so such a build must not start additional
+ * concurrent work either.
+ */
+const IS_MEMORY_CONSTRAINED_BUILD = AGENTS_SERVER_BUILD_WORKER_COUNT === 1;
+
 /**
  * Whether Sentry source maps can be uploaded during production builds.
  */
@@ -69,6 +78,19 @@ const nextConfig: NextConfig = {
 
     experimental: {
         externalDir: true,
+
+        // Note: Next.js turns its build workers off as soon as a `webpack` function is configured, and
+        //       that also turns off the parallel output file tracing pass. The `webpack` function below
+        //       only adds aliases, fallbacks and loaders, so the workers are asked for explicitly.
+        //       Compiling each target in a separate short-lived process also releases its memory as
+        //       soon as that target is done.
+        webpackBuildWorker: true,
+
+        // Note: Collecting the output file traces takes about two minutes and used to run alone between
+        //       the compilation and the static generation. It now runs next to the remaining compilation
+        //       and page generation - except for a build which has to save memory rather than time.
+        parallelServerBuildTraces: !IS_MEMORY_CONSTRAINED_BUILD,
+
         ...(AGENTS_SERVER_BUILD_WORKER_COUNT ? { cpus: AGENTS_SERVER_BUILD_WORKER_COUNT } : {}),
     },
 

package/apps/agents-server/package.json

@@ -1,19 +1,19 @@
 {
     "name": "promptbook-agents-server",
     "scripts": {
-        "generate-reserved-paths": "ts-node ./scripts/generate-reserved-paths/generate-reserved-paths.ts",
-        "prebuild": "npm run generate-reserved-paths && node ./scripts/clearNextGeneratedTypes.js && npx kill-port 4440 ||  exit 0",
-        "predev": "npm run generate-reserved-paths && npx kill-port 4440 ||  exit 0",
+        "generate-reserved-paths": "ts-node --transpile-only ./scripts/generate-reserved-paths/generate-reserved-paths.ts",
+        "prebuild": "npm run generate-reserved-paths && node ./scripts/clearNextGeneratedTypes.js && node ./scripts/kill-port.js 4440",
+        "predev": "npm run generate-reserved-paths && node ./scripts/kill-port.js 4440",
         "dev": "next dev -p 4440",
         "test": "npm run test-e2e",
         "test-e2e": "node ./scripts/run-e2e-tests.js",
-        "pretest-build": "npx kill-port 4021 4440 || exit 0",
+        "pretest-build": "node ./scripts/kill-port.js 4021 4440",
         "test-build": "npm run build",
-        "pretest-e2e": "npx kill-port 4021 4440 || exit 0",
+        "pretest-e2e": "node ./scripts/kill-port.js 4021 4440",
         "build": "node ./scripts/build-agents-server.js",
         "build-e2e": "node ./scripts/build-e2e.js",
         "start": "next start -p 4440",
-        "lint": "eslint src/ --max-warnings=0",
+        "lint": "eslint src/ --max-warnings=0 --cache --cache-location ./node_modules/.cache/eslint/agents-server-src.json",
         "postinstall": "node ./scripts/ensure-root-dependencies.js"
     }
 }

package/apps/agents-server/scripts/build-agents-server.js

@@ -8,6 +8,11 @@ const path = require('node:path');
  */
 const APP_ROOT = path.resolve(__dirname, '..');
 
+/**
+ * Root directory of the repository, which owns the shared build and test scripts.
+ */
+const PROJECT_ROOT = path.resolve(APP_ROOT, '..', '..');
+
 /**
  * Maximum Node.js heap size used by the Next.js production build.
  */
@@ -17,13 +22,14 @@ const AGENTS_SERVER_BUILD_MAX_OLD_SPACE_MIB = 8192;
  * Runs the shared Agents Server production build and its homepage prerender step.
  *
  * The optional `--no-lint` argument is used by the E2E runner after the same app
- * lint command has already completed successfully.
+ * lint command has already completed successfully. The optional `--no-homepage-prerender`
+ * argument is used by builds whose caller starts the very same production server right
+ * afterwards, which makes the extra prerender server a repetition of that work.
  */
 function buildAgentsServer() {
     const nextBuildArguments = [
-        `--max-old-space-size=${AGENTS_SERVER_BUILD_MAX_OLD_SPACE_MIB}`,
         '-r',
-        path.join(APP_ROOT, 'scripts', 'ignore-kill-eperm.js'),
+        path.join(PROJECT_ROOT, 'scripts', 'ignore-kill-eperm.js'),
         path.join(APP_ROOT, 'scripts', 'next-cli.js'),
         'build',
     ];
@@ -32,8 +38,34 @@ function buildAgentsServer() {
         nextBuildArguments.push('--no-lint');
     }
 
-    runChildProcess(process.execPath, nextBuildArguments);
-    runChildProcess(process.execPath, [path.join(APP_ROOT, 'scripts', 'prerender-homepage.js')]);
+    runChildProcess(process.execPath, nextBuildArguments, {
+        // Note: Next.js compiles each webpack target in its own build worker process, and a worker
+        //       inherits the heap limit only through `NODE_OPTIONS` - not through the command line of
+        //       the build process which spawned it. The same merge is done for the CLI-owned
+        //       production build in `src/cli/cli-commands/agents-server/buildAgentsServer/runNextBuild.ts`.
+        NODE_OPTIONS: mergeNodeOptionsWithHeapSize(process.env.NODE_OPTIONS, AGENTS_SERVER_BUILD_MAX_OLD_SPACE_MIB),
+    });
+
+    if (!process.argv.includes('--no-homepage-prerender')) {
+        runChildProcess(process.execPath, [path.join(APP_ROOT, 'scripts', 'prerender-homepage.js')]);
+    }
+}
+
+/**
+ * Prepends `--max-old-space-size=<mib>` to `NODE_OPTIONS` unless the caller already set one.
+ *
+ * @param existingNodeOptions - Inherited `NODE_OPTIONS` value.
+ * @param maxOldSpaceMib - Maximum Node.js heap size in MiB.
+ * @returns `NODE_OPTIONS` value for the build process.
+ */
+function mergeNodeOptionsWithHeapSize(existingNodeOptions, maxOldSpaceMib) {
+    if (existingNodeOptions !== undefined && /--max-old-space-size[= ]/u.test(existingNodeOptions)) {
+        return existingNodeOptions;
+    }
+
+    const heapFlag = `--max-old-space-size=${maxOldSpaceMib}`;
+
+    return existingNodeOptions ? `${heapFlag} ${existingNodeOptions}` : heapFlag;
 }
 
 /**
@@ -41,11 +73,15 @@ function buildAgentsServer() {
  *
  * @param executablePath - Executable to run.
  * @param argumentsList - Arguments passed to the executable.
+ * @param environmentOverrides - Environment variables added on top of the inherited environment.
  */
-function runChildProcess(executablePath, argumentsList) {
+function runChildProcess(executablePath, argumentsList, environmentOverrides = {}) {
     const result = spawnSync(executablePath, argumentsList, {
         cwd: APP_ROOT,
-        env: process.env,
+        env: {
+            ...process.env,
+            ...environmentOverrides,
+        },
         stdio: 'inherit',
     });
 

package/apps/agents-server/scripts/build-e2e.js

@@ -9,6 +9,16 @@ const { runNpm } = require('./run-npm.js');
  */
 const APP_ROOT = path.resolve(__dirname, '..');
 
+/**
+ * Production build arguments which every E2E build applies.
+ *
+ * The homepage prerender starts one more production server only to download `/` into an HTML
+ * snapshot which nothing reads afterwards. Every E2E build is started by Playwright right after it
+ * is compiled, and the tests open the homepage against that very same server, so the snapshot would
+ * only repeat work the tests already do.
+ */
+const E2E_BUILD_ARGUMENTS = ['--no-homepage-prerender'];
+
 /**
  * Builds the production bundle used by the Agents Server E2E tests.
  *
@@ -16,10 +26,10 @@ const APP_ROOT = path.resolve(__dirname, '..');
  * mocked Supabase URL are embedded consistently in browser bundles.
  */
 function buildE2eServer() {
-    const buildArguments = ['run', 'build'];
+    const buildArguments = ['run', 'build', '--', ...E2E_BUILD_ARGUMENTS];
 
     if (process.argv.includes('--no-lint')) {
-        buildArguments.push('--', '--no-lint');
+        buildArguments.push('--no-lint');
     }
 
     runNpm(buildArguments, {

package/apps/agents-server/scripts/generate-reserved-paths/generate-reserved-paths.ts

@@ -1,3 +1,4 @@
+import { spaceTrim } from 'spacetrim';
 import fs from 'fs';
 import path from 'path';
 import { GENERATOR_WARNING } from '../../../../src/config';
@@ -58,18 +59,20 @@ const allReservedPaths = [...new Set([...reservedPaths, ...publicPaths, ...addit
 /**
  * Constant for content.
  */
-const content = `/**
- * Reserved paths that should not be treated as agent names.
- * This file is auto-generated by scripts/generate-reserved-paths.js
- *
- * ${GENERATOR_WARNING}
- *
- * @see /apps/agents-server/src/app - source directory for routes
- * @see /apps/agents-server/public - source directory for static files
- * @see /apps/agents-server/src/middleware.ts - where this is used
- */
-export const RESERVED_PATHS: readonly string[] = ${JSON.stringify(allReservedPaths, null, 4)} as const;
-`;
+const content = spaceTrim(
+    (block) => `/**
+     * Reserved paths that should not be treated as agent names.
+     * This file is auto-generated by scripts/generate-reserved-paths.js
+     *
+     * ${GENERATOR_WARNING}
+     *
+     * @see /apps/agents-server/src/app - source directory for routes
+     * @see /apps/agents-server/public - source directory for static files
+     * @see /apps/agents-server/src/middleware.ts - where this is used
+     */
+    export const RESERVED_PATHS: readonly string[] = ${block(JSON.stringify(allReservedPaths, null, 4))} as const;
+    `,
+);
 
 // Ensure the generated directory exists
 /**
@@ -80,8 +83,19 @@ if (!fs.existsSync(generatedDir)) {
     fs.mkdirSync(generatedDir, { recursive: true });
 }
 
-// Write the file
-fs.writeFileSync(outputFile, content, 'utf-8');
+// Note: Rewriting an unchanged file would only move its modification time forward, which invalidates
+//       the webpack and TypeScript caches of every build and every development server start.
+/**
+ * Constant for current content.
+ */
+const currentContent = fs.existsSync(outputFile) ? fs.readFileSync(outputFile, 'utf-8') : null;
 
-console.log(`Generated ${outputFile} with ${allReservedPaths.length} reserved paths:`);
-console.log(allReservedPaths.join(', '));
+if (currentContent === content) {
+    console.log(`Kept ${outputFile} unchanged with ${allReservedPaths.length} reserved paths.`);
+} else {
+    // Write the file
+    fs.writeFileSync(outputFile, content, 'utf-8');
+
+    console.log(`Generated ${outputFile} with ${allReservedPaths.length} reserved paths:`);
+    console.log(allReservedPaths.join(', '));
+}

package/apps/agents-server/scripts/kill-port.js

@@ -0,0 +1,163 @@
+'use strict';
+
+const { spawnSync } = require('node:child_process');
+
+/**
+ * Frees the given TCP ports before a build, a development server, or an E2E run binds them again.
+ *
+ * This replaces `npx kill-port`, which resolved an undeclared package through the npm registry on
+ * every single invocation. Freeing a port is a best-effort cleanup step, so nothing here may ever
+ * fail the surrounding command.
+ *
+ * Usage: `node ./scripts/kill-port.js 4021 4440`
+ */
+function killPorts() {
+    for (const port of parsePortArguments(process.argv.slice(2))) {
+        const listeningProcessIds = resolveListeningProcessIds(port);
+
+        if (listeningProcessIds.length === 0) {
+            console.log(`No process is listening on port ${port}.`);
+            continue;
+        }
+
+        for (const processId of listeningProcessIds) {
+            if (killProcess(processId)) {
+                console.log(`Freed port ${port} by stopping process ${processId}.`);
+            } else {
+                console.log(`Could not stop process ${processId} listening on port ${port}.`);
+            }
+        }
+    }
+}
+
+/**
+ * Reads the TCP ports from the command line arguments.
+ *
+ * @param {ReadonlyArray<string>} argumentsList - Raw command line arguments.
+ * @returns {Array<number>} Valid TCP ports.
+ */
+function parsePortArguments(argumentsList) {
+    return argumentsList.map((argument) => Number(argument)).filter(isPort);
+}
+
+/**
+ * Returns whether one value is a usable TCP port number.
+ *
+ * @param {number} value - Parsed command line argument.
+ * @returns {boolean} Whether the value can be freed.
+ */
+function isPort(value) {
+    return Number.isInteger(value) && value > 0 && value <= 65535;
+}
+
+/**
+ * Resolves the process ids currently listening on one TCP port.
+ *
+ * @param {number} port - TCP port to inspect.
+ * @returns {Array<number>} Process ids of the listeners.
+ */
+function resolveListeningProcessIds(port) {
+    if (process.platform === 'win32') {
+        return resolveWindowsListeningProcessIds(port);
+    }
+
+    return resolvePosixListeningProcessIds(port);
+}
+
+/**
+ * Resolves listeners of one TCP port through the Windows `netstat` utility.
+ *
+ * @param {number} port - TCP port to inspect.
+ * @returns {Array<number>} Process ids of the listeners.
+ */
+function resolveWindowsListeningProcessIds(port) {
+    const netstatResult = spawnSync('netstat', ['-a', '-n', '-o', '-p', 'TCP'], { encoding: 'utf8' });
+
+    if (typeof netstatResult.stdout !== 'string') {
+        return [];
+    }
+
+    return dedupeProcessIds(
+        netstatResult.stdout
+            .split(/\r?\n/u)
+            .filter((line) => line.includes('LISTENING'))
+            .map((line) => line.trim().split(/\s+/u))
+            .filter((columns) => columns.length >= 5 && isAddressOnPort(columns[1], port))
+            .map((columns) => Number(columns[columns.length - 1])),
+    );
+}
+
+/**
+ * Resolves listeners of one TCP port through the POSIX `lsof` utility.
+ *
+ * @param {number} port - TCP port to inspect.
+ * @returns {Array<number>} Process ids of the listeners.
+ */
+function resolvePosixListeningProcessIds(port) {
+    const listOpenFilesResult = spawnSync('lsof', ['-nP', `-iTCP:${port}`, '-sTCP:LISTEN', '-t'], {
+        encoding: 'utf8',
+    });
+
+    if (typeof listOpenFilesResult.stdout !== 'string') {
+        return [];
+    }
+
+    return dedupeProcessIds(listOpenFilesResult.stdout.split(/\s+/u).map((value) => Number(value)));
+}
+
+/**
+ * Returns whether one `netstat` local address belongs to the inspected port.
+ *
+ * The address is printed as `0.0.0.0:4440`, `127.0.0.1:4440`, or `[::]:4440`.
+ *
+ * @param {string} address - Local address column of one `netstat` row.
+ * @param {number} port - TCP port to inspect.
+ * @returns {boolean} Whether the row belongs to the port.
+ */
+function isAddressOnPort(address, port) {
+    return address.endsWith(`:${port}`);
+}
+
+/**
+ * Keeps only distinct process ids which are safe to stop.
+ *
+ * The current process and its parent are excluded so that freeing a port can never stop the build,
+ * the test runner, or the shell which started them.
+ *
+ * @param {ReadonlyArray<number>} processIds - Raw process ids.
+ * @returns {Array<number>} Distinct stoppable process ids.
+ */
+function dedupeProcessIds(processIds) {
+    return Array.from(
+        new Set(
+            processIds.filter(
+                (processId) =>
+                    Number.isInteger(processId) &&
+                    processId > 0 &&
+                    processId !== process.pid &&
+                    processId !== process.ppid,
+            ),
+        ),
+    );
+}
+
+/**
+ * Stops one process which holds an inspected port.
+ *
+ * @param {number} processId - Process id of the listener.
+ * @returns {boolean} Whether the process was stopped.
+ */
+function killProcess(processId) {
+    if (process.platform === 'win32') {
+        return spawnSync('taskkill', ['/F', '/PID', String(processId)], { stdio: 'ignore' }).status === 0;
+    }
+
+    try {
+        process.kill(processId, 'SIGKILL');
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+killPorts();

package/apps/agents-server/scripts/run-e2e-tests.js

@@ -1,7 +1,7 @@
 'use strict';
 
 const path = require('node:path');
-const { runNpm } = require('./run-npm.js');
+const { runNpm, startNpm, startNpmWithCollectedOutput } = require('./run-npm.js');
 
 /**
  * Root directory of the Agents Server app.
@@ -11,17 +11,30 @@ const APP_ROOT = path.resolve(__dirname, '..');
 /**
  * Runs the complete Agents Server E2E verification flow.
  *
- * App linting remains an explicit test phase. The production build then skips
- * its duplicate lint pass, and Playwright starts that same build instead of
- * compiling a second `.next-e2e` output through `webServer`.
+ * App linting remains an explicit test phase, but it reads only the sources and therefore does not
+ * depend on the production build. Both run at the same time and the flow waits for the slower one,
+ * which is always the build. The build then skips its duplicate lint pass, and Playwright starts
+ * that same build instead of compiling a second `.next-e2e` output through `webServer`.
  */
-function runE2eTests() {
+async function runE2eTests() {
     const commandOptions = {
         cwd: APP_ROOT,
     };
 
-    runNpm(['run', 'lint'], commandOptions);
-    runNpm(['run', 'build-e2e', '--', '--no-lint'], commandOptions);
+    const lintCompletion = startNpmWithCollectedOutput(['run', 'lint'], commandOptions);
+    const buildStatus = await startNpm(['run', 'build-e2e', '--', '--no-lint'], commandOptions);
+    const lintResult = await lintCompletion;
+
+    console.log('\n> lint (ran next to the production build)\n');
+    process.stdout.write(lintResult.output);
+
+    if (lintResult.status !== 0) {
+        process.exit(lintResult.status);
+    }
+
+    if (buildStatus !== 0) {
+        process.exit(buildStatus);
+    }
 
     runNpm(['exec', '--', 'playwright', 'test', ...process.argv.slice(2)], {
         ...commandOptions,
@@ -31,4 +44,4 @@ function runE2eTests() {
     });
 }
 
-runE2eTests();
+void runE2eTests();

package/apps/agents-server/scripts/run-npm.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const { spawnSync } = require('node:child_process');
+const { spawn, spawnSync } = require('node:child_process');
 
 /**
  * Platform-specific npm executable.
@@ -8,22 +8,34 @@ const { spawnSync } = require('node:child_process');
 const NPM_EXECUTABLE = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 
 /**
- * Runs one npm command and forwards its output and exit status.
+ * Creates the spawn options shared by every npm command of the Agents Server scripts.
  *
  * Windows resolves npm through a `.cmd` shim, which needs shell execution when spawned from
  * Node.js on some supported Node versions.
  *
- * @param {ReadonlyArray<string>} argumentsList - Arguments passed to npm.
  * @param {{ cwd: string, environmentOverrides?: Readonly<Record<string, string>> }} options - Command options.
+ * @returns {{ cwd: string, env: Record<string, string|undefined>, shell: boolean }} Shared spawn options.
  */
-function runNpm(argumentsList, { cwd, environmentOverrides = {} }) {
-    const result = spawnSync(NPM_EXECUTABLE, argumentsList, {
+function createNpmSpawnOptions({ cwd, environmentOverrides = {} }) {
+    return {
         cwd,
         env: {
             ...process.env,
             ...environmentOverrides,
         },
         shell: process.platform === 'win32',
+    };
+}
+
+/**
+ * Runs one npm command, waits for it, and forwards its output and exit status.
+ *
+ * @param {ReadonlyArray<string>} argumentsList - Arguments passed to npm.
+ * @param {{ cwd: string, environmentOverrides?: Readonly<Record<string, string>> }} options - Command options.
+ */
+function runNpm(argumentsList, options) {
+    const result = spawnSync(NPM_EXECUTABLE, argumentsList, {
+        ...createNpmSpawnOptions(options),
         stdio: 'inherit',
     });
 
@@ -37,6 +49,70 @@ function runNpm(argumentsList, { cwd, environmentOverrides = {} }) {
     }
 }
 
+/**
+ * Starts one npm command without waiting for it and forwards its output to this terminal.
+ *
+ * @param {ReadonlyArray<string>} argumentsList - Arguments passed to npm.
+ * @param {{ cwd: string, environmentOverrides?: Readonly<Record<string, string>> }} options - Command options.
+ * @returns {Promise<number>} Exit status of the finished command.
+ */
+function startNpm(argumentsList, options) {
+    return waitForNpm(
+        spawn(NPM_EXECUTABLE, argumentsList, {
+            ...createNpmSpawnOptions(options),
+            stdio: 'inherit',
+        }),
+    );
+}
+
+/**
+ * Starts one npm command without waiting for it and collects its output instead of printing it.
+ *
+ * Two commands running next to each other cannot share this terminal line by line, so the output of
+ * the quieter one is kept and printed as one readable block once it has finished.
+ *
+ * @param {ReadonlyArray<string>} argumentsList - Arguments passed to npm.
+ * @param {{ cwd: string, environmentOverrides?: Readonly<Record<string, string>> }} options - Command options.
+ * @returns {Promise<{ status: number, output: string }>} Exit status and collected output.
+ */
+function startNpmWithCollectedOutput(argumentsList, options) {
+    const npmProcess = spawn(NPM_EXECUTABLE, argumentsList, {
+        ...createNpmSpawnOptions(options),
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+
+    let output = '';
+    const collectOutput = (chunk) => {
+        output = `${output}${chunk.toString()}`;
+    };
+
+    npmProcess.stdout?.on('data', collectOutput);
+    npmProcess.stderr?.on('data', collectOutput);
+
+    return waitForNpm(npmProcess).then((status) => ({ status, output }));
+}
+
+/**
+ * Waits for one started npm command and reports its exit status.
+ *
+ * @param {import('node:child_process').ChildProcess} npmProcess - Started npm command.
+ * @returns {Promise<number>} Exit status of the finished command.
+ */
+function waitForNpm(npmProcess) {
+    return new Promise((resolve) => {
+        npmProcess.once('error', (error) => {
+            console.error(`Failed to run ${NPM_EXECUTABLE}:`, error);
+            resolve(1);
+        });
+
+        npmProcess.once('close', (status) => {
+            resolve(status ?? 1);
+        });
+    });
+}
+
 module.exports = {
     runNpm,
+    startNpm,
+    startNpmWithCollectedOutput,
 };

package/apps/agents-server/src/app/actions.ts

@@ -15,6 +15,7 @@ import { buildAgentChatHref, buildAgentProfileHref } from '../utils/agentRouting
 import { type AgentVisibility, parseAgentVisibility } from '../utils/agentVisibility';
 import { authenticateUserWithRateLimit } from '../utils/authenticateUser';
 import { resolveAuthenticationAttemptHeaderIp } from '../utils/authenticationAttemptRateLimit';
+import { recordAgentGoalChatLifecycleNote } from '../utils/agentGoalChat';
 import { createAgentWithDefaultVisibility } from '../utils/createAgentWithDefaultVisibility';
 import { resolveCurrentUserIdentity } from '../utils/currentUserIdentity';
 import { isUserAdmin } from '../utils/isUserAdmin';
@@ -49,6 +50,7 @@ export async function $createAgentAction(): Promise<{ agentName: string_agent_na
     const { agentName, permanentId } = await createAgentWithDefaultVisibility(collection, agentSource, {
         userId: currentUserIdentity?.userId,
     });
+    await recordAgentGoalChatLifecycleNote({ event: 'CREATED', agentPermanentId: permanentId, agentName });
     revalidateCreatedAgentPaths(permanentId);
     await waitForCreatedAgentRoute(permanentId);
 
@@ -139,6 +141,7 @@ export async function $createAgentFromBookAction(
         visibility: visibility ?? undefined,
         userId: currentUserIdentity?.userId,
     });
+    await recordAgentGoalChatLifecycleNote({ event: 'CREATED', agentPermanentId: permanentId, agentName });
     revalidateCreatedAgentPaths(permanentId);
     await waitForCreatedAgentRoute(permanentId);