@soleri/core 9.11.0 → 9.13.0

package/src/embeddings/pipeline.ts

@@ -0,0 +1,126 @@
+/**
+ * Embedding pipeline — batch and incremental embedding of vault entries.
+ */
+import type { EmbeddingProvider } from './types.js';
+import type { PersistenceProvider } from '../persistence/types.js';
+import { storeVector, getVector, getEntriesWithoutVectors } from '../vault/vault-entries.js';
+
+export interface BatchEmbedOptions {
+  /** Number of entries per API call (default 100). */
+  batchSize?: number;
+  /** Called after each batch with (completed, total). */
+  onProgress?: (completed: number, total: number) => void;
+}
+
+export interface BatchEmbedResult {
+  embedded: number;
+  skipped: number;
+  failed: number;
+  tokensUsed: number;
+}
+
+export class EmbeddingPipeline {
+  constructor(
+    private provider: EmbeddingProvider,
+    private persistence: PersistenceProvider,
+  ) {}
+
+  /**
+   * Batch embed all entries missing vectors for the current model.
+   * Processes in chunks; skips entries that already have vectors.
+   * On batch failure, logs and continues with the next batch.
+   */
+  async batchEmbed(options?: BatchEmbedOptions): Promise<BatchEmbedResult> {
+    const batchSize = options?.batchSize ?? 100;
+    const onProgress = options?.onProgress;
+
+    const missingIds = getEntriesWithoutVectors(this.persistence, this.provider.model);
+    if (missingIds.length === 0) {
+      return { embedded: 0, skipped: 0, failed: 0, tokensUsed: 0 };
+    }
+
+    let embedded = 0;
+    let failed = 0;
+    let tokensUsed = 0;
+
+    for (let i = 0; i < missingIds.length; i += batchSize) {
+      const batchIds = missingIds.slice(i, i + batchSize);
+
+      // Load entries for this batch
+      const placeholders = batchIds.map(() => '?').join(',');
+      const rows = this.persistence.all<{
+        id: string;
+        title: string;
+        description: string;
+        context: string;
+      }>(
+        `SELECT id, title, description, context FROM entries WHERE id IN (${placeholders})`,
+        batchIds,
+      );
+
+      if (rows.length === 0) continue;
+
+      const texts = rows.map((r) => this.getEmbeddableText(r));
+
+      try {
+        const result = await this.provider.embed(texts);
+        for (let j = 0; j < rows.length; j++) {
+          storeVector(
+            this.persistence,
+            rows[j].id,
+            result.vectors[j],
+            this.provider.model,
+            this.provider.dimensions,
+          );
+          embedded++;
+        }
+        tokensUsed += result.tokensUsed;
+      } catch (err) {
+        // Log and continue — don't abort entire pipeline for one bad batch
+        console.error(`[EmbeddingPipeline] batch failed (offset ${i}):`, err);
+        failed += batchIds.length;
+      }
+
+      onProgress?.(embedded + failed, missingIds.length);
+    }
+
+    return {
+      embedded,
+      skipped: 0,
+      failed,
+      tokensUsed,
+    };
+  }
+
+  /**
+   * Embed a single entry and store its vector.
+   * Returns true if embedded, false if skipped (vector already exists).
+   */
+  async embedEntry(entryId: string, text: string): Promise<boolean> {
+    const existing = getVector(this.persistence, entryId);
+    if (existing && existing.model === this.provider.model) return false;
+
+    const result = await this.provider.embed([text]);
+    storeVector(
+      this.persistence,
+      entryId,
+      result.vectors[0],
+      this.provider.model,
+      this.provider.dimensions,
+    );
+    return true;
+  }
+
+  /** Build the text to embed for a vault entry. */
+  private getEmbeddableText(entry: {
+    title?: string;
+    description?: string;
+    context?: string;
+  }): string {
+    const parts: string[] = [];
+    if (entry.title) parts.push(entry.title);
+    if (entry.description) parts.push(entry.description);
+    if (entry.context) parts.push(entry.context);
+    return parts.join('\n');
+  }
+}

package/src/embeddings/types.ts

@@ -0,0 +1,67 @@
+// ─── Embedding Types ─────────────────────────────────────────────
+
+/** Result of an embedding call — vectors plus metadata. */
+export interface EmbeddingResult {
+  /** One vector per input text, each vector is number[] of length = dimensions. */
+  vectors: number[][];
+  /** Total tokens consumed by this call. */
+  tokensUsed: number;
+  /** Model that produced these embeddings. */
+  model: string;
+}
+
+/** Provider-agnostic interface for generating dense vector embeddings. */
+export interface EmbeddingProvider {
+  /** Provider name (e.g. 'openai', 'ollama'). */
+  readonly providerName: string;
+  /** Model identifier (e.g. 'text-embedding-3-small'). */
+  readonly model: string;
+  /** Vector dimensions produced by this model. */
+  readonly dimensions: number;
+  /** Embed one or more texts, returning one vector per text. */
+  embed(texts: string[]): Promise<EmbeddingResult>;
+}
+
+/** Configuration for initializing an embedding provider. */
+export interface EmbeddingConfig {
+  /** Which provider to use: 'openai' | 'ollama' | string. */
+  provider: string;
+  /** Model to use for embeddings. */
+  model: string;
+  /** Optional API key override (otherwise uses KeyPool). */
+  apiKey?: string;
+  /** Optional base URL override (for self-hosted or proxy). */
+  baseUrl?: string;
+  /** Max texts per batch API call (provider-specific default if omitted). */
+  batchSize?: number;
+}
+
+/** A persisted embedding vector tied to a vault entry. */
+export interface StoredVector {
+  /** Vault entry ID this vector belongs to. */
+  entryId: string;
+  /** The embedding vector. */
+  vector: number[];
+  /** Model that produced this vector. */
+  model: string;
+  /** Number of dimensions in the vector. */
+  dimensions: number;
+  /** Unix timestamp (ms) when this vector was created. */
+  createdAt: number;
+}
+
+/** Aggregate statistics for the embedding subsystem. */
+export interface EmbeddingStats {
+  /** Active provider name. */
+  provider: string;
+  /** Active model name. */
+  model: string;
+  /** Vector dimensions for the active model. */
+  dimensions: number;
+  /** Number of entries with embeddings. */
+  totalEmbedded: number;
+  /** Number of entries missing embeddings. */
+  totalMissing: number;
+  /** Cumulative tokens consumed across all embedding calls. */
+  totalTokensUsed: number;
+}

package/src/engine/bin/soleri-engine.ts

@@ -163,7 +163,7 @@ async function main(): Promise<void> {
       .join(', ')})`,
   );
 
-  // 6b. Auto-sync skills to ~/.claude/commands/
+  // 6b. Auto-sync skills to ~/.claude/skills/
   const skillsDir = join(agentDir, 'skills');
   if (existsSync(skillsDir)) {
     const syncResult = syncSkillsToClaudeCode([skillsDir], config.name as string);
@@ -173,6 +173,9 @@ async function main(): Promise<void> {
         `${tag} Skills synced: ${syncResult.installed.length} new, ${syncResult.updated.length} updated`,
       );
     }
+    if (syncResult.removed.length) {
+      console.error(`${tag} Removed ${syncResult.removed.length} orphaned skill(s)`);
+    }
   }
 
   // 7. Load domain packs

package/src/engine/module-manifest.test.ts

@@ -32,8 +32,8 @@ describe('ENGINE_MODULE_MANIFEST', () => {
     expect(suffixes).toContain('intake');
   });
 
-  it('has exactly 20 modules', () => {
-    expect(ENGINE_MODULE_MANIFEST).toHaveLength(20);
+  it('has exactly 22 modules', () => {
+    expect(ENGINE_MODULE_MANIFEST).toHaveLength(22);
   });
 
   it('has no duplicate suffixes', () => {
@@ -168,7 +168,7 @@ describe('manifest order stability', () => {
     expect(ENGINE_MODULE_MANIFEST[0].suffix).toBe('vault');
   });
 
-  it('tier is the last module', () => {
-    expect(ENGINE_MODULE_MANIFEST[ENGINE_MODULE_MANIFEST.length - 1].suffix).toBe('tier');
+  it('dream is the last module', () => {
+    expect(ENGINE_MODULE_MANIFEST[ENGINE_MODULE_MANIFEST.length - 1].suffix).toBe('dream');
   });
 });

package/src/engine/module-manifest.ts

@@ -231,6 +231,16 @@ export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
       'merge branch': 'vault_merge_branch',
     },
   },
+  {
+    suffix: 'embedding',
+    description: 'Embedding management — status, batch rebuild, single-entry embedding.',
+    keyOps: ['embed_status', 'embed_rebuild', 'embed_entry'],
+    intentSignals: {
+      'embedding status': 'embed_status',
+      'rebuild embeddings': 'embed_rebuild',
+      'embed entry': 'embed_entry',
+    },
+  },
   {
     suffix: 'tier',
     description: 'Multi-vault tiers — connect, disconnect, search across sources.',
@@ -241,6 +251,16 @@ export const ENGINE_MODULE_MANIFEST: ModuleManifestEntry[] = [
       'list sources': 'vault_list_sources',
     },
   },
+  {
+    suffix: 'dream',
+    description: 'Dream — automatic memory consolidation, vault cleanup, and maintenance.',
+    keyOps: ['dream_status', 'dream_trigger', 'dream_history'],
+    intentSignals: {
+      'dream status': 'dream_status',
+      'run dream': 'dream_trigger',
+      'dream history': 'dream_history',
+    },
+  },
 ];
 
 /** Core facade ops (always present, not in ENGINE_MODULES) */

package/src/engine/register-engine.ts

@@ -43,6 +43,8 @@ import { createIntakeFacadeOps } from '../runtime/facades/intake-facade.js';
 import { createLinksFacadeOps } from '../runtime/facades/links-facade.js';
 import { createBranchingFacadeOps } from '../runtime/facades/branching-facade.js';
 import { createTierFacadeOps } from '../runtime/facades/tier-facade.js';
+import { createEmbeddingFacadeOps } from '../runtime/facades/embedding-facade.js';
+import { createDreamOps } from '../dream/dream-ops.js';
 import { createDomainFacade } from '../runtime/domain-ops.js';
 
 // ─── Types ────────────────────────────────────────────────────────────
@@ -185,11 +187,21 @@ export const ENGINE_MODULES: ModuleDef[] = [
     description: 'Vault branching — create, list, merge, delete branches.',
     createOps: createBranchingFacadeOps,
   },
+  {
+    suffix: 'embedding',
+    description: 'Embedding management — status, batch rebuild, single-entry embedding.',
+    createOps: createEmbeddingFacadeOps,
+  },
   {
     suffix: 'tier',
     description: 'Multi-vault tiers — connect, disconnect, search across sources.',
     createOps: createTierFacadeOps,
   },
+  {
+    suffix: 'dream',
+    description: 'Dream — automatic memory consolidation, vault cleanup, and maintenance.',
+    createOps: createDreamOps,
+  },
 ];
 
 // ─── Core Registration ────────────────────────────────────────────────

package/src/flows/dispatch-registry.ts

@@ -10,14 +10,51 @@ import type { FacadeConfig } from '../facades/types.js';
 type DispatchResult = { tool: string; status: string; data?: unknown; error?: string };
 type DispatchFn = (toolName: string, params: Record<string, unknown>) => Promise<DispatchResult>;
 
+export interface ActivePlanRef {
+  steps: Array<{ id: string; allowedTools?: string[]; status: string }>;
+  deviations?: Array<{
+    stepId: string;
+    expectedTools: string[];
+    actualTool: string;
+    timestamp: string;
+  }>;
+}
+
+/**
+ * Check whether the tool call deviates from the current running step's allowedTools.
+ * If it does, record the deviation on the plan (warn-only, does not block execution).
+ */
+function checkDeviation(activePlan: ActivePlanRef, toolName: string, opName: string): void {
+  const currentStep = activePlan.steps.find((s) => s.status === 'running');
+  if (currentStep?.allowedTools && currentStep.allowedTools.length > 0) {
+    if (
+      !currentStep.allowedTools.includes(toolName) &&
+      !currentStep.allowedTools.includes(opName)
+    ) {
+      if (!activePlan.deviations) activePlan.deviations = [];
+      activePlan.deviations.push({
+        stepId: currentStep.id,
+        expectedTools: currentStep.allowedTools,
+        actualTool: toolName,
+        timestamp: new Date().toISOString(),
+      });
+    }
+  }
+}
+
 /**
  * Create a dispatcher function that routes tool calls to the correct facade op.
  *
  * @param agentId - Agent identifier prefix (e.g. "myagent")
  * @param facades - Array of registered facade configs
+ * @param activePlan - Optional active plan reference for deviation tracking
  * @returns A dispatch function that takes (toolName, params) and calls the matching handler
  */
-export function createDispatcher(agentId: string, facades: FacadeConfig[]): DispatchFn {
+export function createDispatcher(
+  agentId: string,
+  facades: FacadeConfig[],
+  activePlan?: ActivePlanRef,
+): DispatchFn {
   // Build a lookup map: facadeName → { opName → handler }
   const facadeMap = new Map<string, FacadeConfig>();
   for (const facade of facades) {
@@ -45,6 +82,9 @@ export function createDispatcher(agentId: string, facades: FacadeConfig[]): Disp
       const op = facade.ops.find((o) => o.name === opName);
       if (!op) continue;
 
+      // Check for plan deviation (warn-only)
+      if (activePlan) checkDeviation(activePlan, toolName, opName);
+
       try {
         const result = await op.handler(params);
         return { tool: toolName, status: 'ok', data: result };
@@ -62,6 +102,9 @@ export function createDispatcher(agentId: string, facades: FacadeConfig[]): Disp
     if (facade && params.op && typeof params.op === 'string') {
       const op = facade.ops.find((o) => o.name === params.op);
       if (op) {
+        // Check for plan deviation (warn-only)
+        if (activePlan) checkDeviation(activePlan, toolName, params.op as string);
+
         try {
           const result = await op.handler(params);
           return { tool: toolName, status: 'ok', data: result };

package/src/flows/executor.ts

@@ -3,7 +3,9 @@
  * evaluating gates and handling branching.
  */
 
-import type { OrchestrationPlan, ExecutionResult, StepResult } from './types.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import type { OrchestrationPlan, ExecutionResult, StepResult, PlanRunManifest } from './types.js';
 import { evaluateGate } from './gate-evaluator.js';
 
 /** Maximum iterations for BRANCH loops to prevent infinite cycles. */
@@ -14,14 +16,81 @@ type DispatchFn = (
   params: Record<string, unknown>,
 ) => Promise<{ tool: string; status: string; data?: unknown; error?: string }>;
 
+// ---------------------------------------------------------------------------
+// Step persistence helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Resolve the persistence directory for a plan run.
+ * Returns `{persistDir}/.soleri/plan-runs/{planId}/`.
+ */
+export function getPlanRunDir(persistDir: string, planId: string): string {
+  return path.join(persistDir, '.soleri', 'plan-runs', planId);
+}
+
+/**
+ * Load or create a PlanRunManifest from disk.
+ */
+export function loadManifest(runDir: string, planId: string): PlanRunManifest {
+  const manifestPath = path.join(runDir, 'manifest.json');
+  if (fs.existsSync(manifestPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(manifestPath, 'utf-8')) as PlanRunManifest;
+    } catch {
+      // Malformed manifest — return fresh one
+    }
+  }
+  const now = new Date().toISOString();
+  return { planId, steps: {}, lastRun: now, createdAt: now };
+}
+
+/**
+ * Write a PlanRunManifest to disk.
+ */
+export function saveManifest(runDir: string, manifest: PlanRunManifest): void {
+  fs.mkdirSync(runDir, { recursive: true });
+  fs.writeFileSync(path.join(runDir, 'manifest.json'), JSON.stringify(manifest, null, 2));
+}
+
+/**
+ * Persist a single step's output to disk and update the manifest.
+ */
+export function persistStepOutput(
+  runDir: string,
+  manifest: PlanRunManifest,
+  stepIndex: number,
+  stepId: string,
+  output: unknown,
+): void {
+  fs.mkdirSync(runDir, { recursive: true });
+  const safeStepId = stepId.replace(/[/\\:*?"<>|.]/g, '_');
+  const fileName = `step-${stepIndex}-${safeStepId}.json`;
+  fs.writeFileSync(path.join(runDir, fileName), JSON.stringify(output, null, 2));
+
+  const existing = manifest.steps[stepId];
+  const now = new Date().toISOString();
+
+  manifest.steps[stepId] = {
+    status: 'completed',
+    output,
+    timestamp: now,
+    rerunCount: existing ? existing.rerunCount + 1 : 0,
+    rerunReason: existing?.rerunReason,
+  };
+  manifest.lastRun = now;
+  saveManifest(runDir, manifest);
+}
+
 /**
  * Executes an orchestration plan sequentially (with parallel inner steps).
  */
 export class FlowExecutor {
   private dispatch: DispatchFn;
+  private persistDir: string | undefined;
 
-  constructor(dispatch: DispatchFn) {
+  constructor(dispatch: DispatchFn, persistDir?: string) {
     this.dispatch = dispatch;
+    this.persistDir = persistDir;
   }
 
   /**
@@ -35,6 +104,14 @@ export class FlowExecutor {
     let branchIterations = 0;
     let currentIndex = 0;
 
+    // Set up persistence if configured
+    let runDir: string | undefined;
+    let manifest: PlanRunManifest | undefined;
+    if (this.persistDir) {
+      runDir = getPlanRunDir(this.persistDir, plan.planId);
+      manifest = loadManifest(runDir, plan.planId);
+    }
+
     while (currentIndex < plan.steps.length) {
       const step = plan.steps[currentIndex];
       const stepStart = Date.now();
@@ -121,6 +198,20 @@ export class FlowExecutor {
 
       stepResults.push(stepResult);
 
+      // Persist step output to disk if configured
+      if (runDir && manifest) {
+        try {
+          persistStepOutput(runDir, manifest, currentIndex, step.id, {
+            toolResults,
+            gateResult: stepResult.gateResult,
+            status: stepResult.status,
+            durationMs: stepResult.durationMs,
+          });
+        } catch {
+          // Persistence is best-effort — never blocks execution
+        }
+      }
+
       // Handle gate action
       switch (verdict.action) {
         case 'STOP':

package/src/flows/index.ts

@@ -17,6 +17,7 @@ export type {
   StepResult,
   ExecutionResult,
   GateVerdict,
+  ToolDeviation,
 } from './types.js';
 
 // Loader
@@ -47,6 +48,7 @@ export { FlowExecutor } from './executor.js';
 
 // Dispatch registry
 export { createDispatcher } from './dispatch-registry.js';
+export type { ActivePlanRef } from './dispatch-registry.js';
 
 // Epilogue
 export { runEpilogue } from './epilogue.js';

package/src/flows/types.ts

@@ -151,13 +151,22 @@ export interface PlanStep {
   tools: string[];
   parallel: boolean;
   requires: ProbeName[];
+  allowedTools?: string[];
   gate?: {
     type: string;
     condition?: string;
     min?: number;
     onFail?: { action: string; goto?: string; message?: string };
   };
-  status: 'pending' | 'running' | 'passed' | 'failed' | 'skipped' | 'gate-paused';
+  status:
+    | 'pending'
+    | 'running'
+    | 'passed'
+    | 'failed'
+    | 'skipped'
+    | 'gate-paused'
+    | 'stale'
+    | 'rerun';
 }
 
 export interface SkippedStep {
@@ -166,6 +175,13 @@ export interface SkippedStep {
   reason: string;
 }
 
+export interface ToolDeviation {
+  stepId: string;
+  expectedTools: string[];
+  actualTool: string;
+  timestamp: string;
+}
+
 export interface OrchestrationPlan {
   planId: string;
   intent: string;
@@ -177,6 +193,7 @@ export interface OrchestrationPlan {
   summary: string;
   estimatedTools: number;
   context: OrchestrationContext;
+  deviations?: ToolDeviation[];
 }
 
 export interface OrchestrationContext {
@@ -186,6 +203,27 @@ export interface OrchestrationContext {
   projectPath: string;
 }
 
+// ---------------------------------------------------------------------------
+// Step persistence (incremental correction protocol)
+// ---------------------------------------------------------------------------
+
+export type StepPersistenceStatus = 'completed' | 'stale' | 'invalidated' | 'rerun';
+
+export interface StepState {
+  status: StepPersistenceStatus;
+  output: unknown;
+  timestamp: string;
+  rerunCount: number;
+  rerunReason?: string;
+}
+
+export interface PlanRunManifest {
+  planId: string;
+  steps: Record<string, StepState>;
+  lastRun: string;
+  createdAt: string;
+}
+
 // ---------------------------------------------------------------------------
 // Execution
 // ---------------------------------------------------------------------------

package/src/index.ts

@@ -17,6 +17,7 @@ export { TaskCheckout } from './subagent/task-checkout.js';
 export { WorkspaceResolver } from './subagent/workspace-resolver.js';
 export { ConcurrencyManager } from './subagent/concurrency-manager.js';
 export { OrphanReaper } from './subagent/orphan-reaper.js';
+export type { ReapResult } from './subagent/orphan-reaper.js';
 export { aggregate as aggregateResults } from './subagent/result-aggregator.js';
 export type {
   SubagentTask,
@@ -160,6 +161,16 @@ export type {
   CuratorStatus,
 } from './curator/types.js';
 
+// ─── Dream ──────────────────────────────────────────────────────────
+export { DreamEngine, ensureDreamSchema, createDreamOps } from './dream/index.js';
+export {
+  getSchedule as getDreamSchedule,
+  schedule as scheduleDream,
+  unschedule as unscheduleDream,
+} from './dream/index.js';
+export type { DreamReport, DreamStatus } from './dream/dream-engine.js';
+export type { CronSchedule } from './dream/cron-manager.js';
+
 // ─── Governance ─────────────────────────────────────────────────────
 export { Governance } from './governance/governance.js';
 export type {
@@ -590,6 +601,7 @@ export type {
 } from './persona/types.js';
 export {
   ITALIAN_CRAFTSPERSON,
+  NEUTRAL_PERSONA,
   PERSONA_TEMPLATES,
   createDefaultPersona,
 } from './persona/defaults.js';

package/src/persona/defaults.test.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect } from 'vitest';
-import { ITALIAN_CRAFTSPERSON, PERSONA_TEMPLATES, createDefaultPersona } from './defaults.js';
+import {
+  ITALIAN_CRAFTSPERSON,
+  NEUTRAL_PERSONA,
+  PERSONA_TEMPLATES,
+  createDefaultPersona,
+} from './defaults.js';
 
 describe('ITALIAN_CRAFTSPERSON', () => {
   it('uses italian-craftsperson template id', () => {
@@ -25,11 +30,44 @@ describe('ITALIAN_CRAFTSPERSON', () => {
   });
 });
 
+describe('NEUTRAL_PERSONA', () => {
+  it('uses neutral-custom template id', () => {
+    expect(NEUTRAL_PERSONA.template).toBe('neutral-custom');
+  });
+
+  it('has non-empty voice and inspiration', () => {
+    expect(NEUTRAL_PERSONA.voice.length).toBeGreaterThan(0);
+    expect(NEUTRAL_PERSONA.inspiration.length).toBeGreaterThan(0);
+  });
+
+  it('has no cultural flavor', () => {
+    expect(NEUTRAL_PERSONA.culture).toBe('');
+  });
+
+  it('has all arrays populated with minimum counts', () => {
+    expect(NEUTRAL_PERSONA.traits.length).toBeGreaterThanOrEqual(3);
+    expect(NEUTRAL_PERSONA.quirks.length).toBeGreaterThanOrEqual(3);
+    expect(NEUTRAL_PERSONA.opinions.length).toBeGreaterThanOrEqual(3);
+    expect(NEUTRAL_PERSONA.metaphors.length).toBeGreaterThanOrEqual(3);
+    expect(NEUTRAL_PERSONA.greetings.length).toBeGreaterThanOrEqual(2);
+    expect(NEUTRAL_PERSONA.signoffs.length).toBeGreaterThanOrEqual(2);
+  });
+
+  it('has non-empty language and name rules', () => {
+    expect(NEUTRAL_PERSONA.languageRule.length).toBeGreaterThan(0);
+    expect(NEUTRAL_PERSONA.nameRule.length).toBeGreaterThan(0);
+  });
+});
+
 describe('PERSONA_TEMPLATES', () => {
   it('contains italian-craftsperson entry', () => {
     expect(PERSONA_TEMPLATES['italian-craftsperson']).toBe(ITALIAN_CRAFTSPERSON);
   });
 
+  it('contains neutral-custom entry', () => {
+    expect(PERSONA_TEMPLATES['neutral-custom']).toBe(NEUTRAL_PERSONA);
+  });
+
   it('does not include name or history in template entries', () => {
     for (const tmpl of Object.values(PERSONA_TEMPLATES)) {
       expect(tmpl).not.toHaveProperty('name');