@soleri/cli 9.7.2 → 9.9.0

package/src/commands/install.ts

@@ -1,7 +1,14 @@
 import type { Command } from 'commander';
 import { createRequire } from 'node:module';
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
-import { join, resolve } from 'node:path';
+import {
+  accessSync,
+  constants as fsConstants,
+  existsSync,
+  readFileSync,
+  writeFileSync,
+  mkdirSync,
+} from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import * as p from '@clack/prompts';
 import { detectAgent } from '../utils/agent-context.js';
@@ -11,6 +18,9 @@ const SOLERI_HOME = process.env.SOLERI_HOME ?? join(homedir(), '.soleri');
 
 type Target = 'claude' | 'codex' | 'opencode' | 'both' | 'all';
 
+/** Normalize a file path to forward slashes (POSIX) for cross-platform config files. */
+export const toPosix = (p: string): string => p.replace(/\\/g, '/');
+
 /**
  * Resolve the absolute path to the soleri-engine binary.
  * Falls back to `npx @soleri/engine` if resolution fails (e.g. not installed globally).
@@ -28,17 +38,18 @@ function resolveEngineBin(): { command: string; bin: string } {
 /** MCP server entry for file-tree agents (resolved engine path, no npx) */
 function fileTreeMcpEntry(agentDir: string): Record<string, unknown> {
   const engine = resolveEngineBin();
+  const agentYaml = toPosix(join(agentDir, 'agent.yaml'));
   if (engine.command === 'node') {
     return {
       type: 'stdio',
       command: 'node',
-      args: [engine.bin, '--agent', join(agentDir, 'agent.yaml')],
+      args: [toPosix(engine.bin), '--agent', agentYaml],
     };
   }
   return {
     type: 'stdio',
     command: 'npx',
-    args: ['@soleri/engine', '--agent', join(agentDir, 'agent.yaml')],
+    args: ['@soleri/engine', '--agent', agentYaml],
   };
 }
 
@@ -47,13 +58,36 @@ function legacyMcpEntry(agentDir: string): Record<string, unknown> {
   return {
     type: 'stdio',
     command: 'node',
-    args: [join(agentDir, 'dist', 'index.js')],
+    args: [toPosix(join(agentDir, 'dist', 'index.js'))],
     env: {},
   };
 }
 
+/**
+ * Check if a file path is writable. If the file exists, checks write permission on the file.
+ * If the file does not exist, checks write permission on the parent directory.
+ */
+function checkWritable(filePath: string): boolean {
+  try {
+    if (existsSync(filePath)) {
+      accessSync(filePath, fsConstants.W_OK);
+    } else {
+      accessSync(dirname(filePath), fsConstants.W_OK);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
 export function installClaude(agentId: string, agentDir: string, isFileTree: boolean): void {
   const configPath = join(homedir(), '.claude.json');
+
+  if (!checkWritable(configPath)) {
+    p.log.error(`Cannot write to ${configPath} — check file permissions`);
+    process.exit(1);
+  }
+
   let config: Record<string, unknown> = {};
 
   if (existsSync(configPath)) {
@@ -73,7 +107,12 @@ export function installClaude(agentId: string, agentDir: string, isFileTree: boo
     ? fileTreeMcpEntry(agentDir)
     : legacyMcpEntry(agentDir);
 
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  try {
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  } catch {
+    p.log.error(`Cannot write to ${configPath}. Check file permissions.`);
+    process.exit(1);
+  }
   p.log.success(`Registered ${agentId} in ~/.claude.json`);
 }
 
@@ -82,7 +121,12 @@ function installCodex(agentId: string, agentDir: string, isFileTree: boolean): v
   const configPath = join(codexDir, 'config.toml');
 
   if (!existsSync(codexDir)) {
-    mkdirSync(codexDir, { recursive: true });
+    try {
+      mkdirSync(codexDir, { recursive: true });
+    } catch {
+      p.log.error(`Cannot create directory ${codexDir}. Check permissions.`);
+      process.exit(1);
+    }
   }
 
   let content = '';
@@ -97,21 +141,27 @@ function installCodex(agentId: string, agentDir: string, isFileTree: boolean): v
 
   let section: string;
   if (isFileTree) {
-    const agentYamlPath = join(agentDir, 'agent.yaml');
+    const agentYamlPath = toPosix(join(agentDir, 'agent.yaml'));
     const engine = resolveEngineBin();
     if (engine.command === 'node') {
-      section = `\n\n${sectionHeader}\ncommand = "node"\nargs = ["${engine.bin}", "--agent", "${agentYamlPath}"]\n`;
+      const bin = toPosix(engine.bin);
+      section = `\n\n${sectionHeader}\ncommand = "node"\nargs = ["${bin}", "--agent", "${agentYamlPath}"]\n`;
     } else {
       section = `\n\n${sectionHeader}\ncommand = "npx"\nargs = ["@soleri/engine", "--agent", "${agentYamlPath}"]\n`;
     }
   } else {
-    const entryPoint = join(agentDir, 'dist', 'index.js');
+    const entryPoint = toPosix(join(agentDir, 'dist', 'index.js'));
     section = `\n\n${sectionHeader}\ncommand = "node"\nargs = ["${entryPoint}"]\n`;
   }
 
   content = content + section;
 
-  writeFileSync(configPath, content.trim() + '\n', 'utf-8');
+  try {
+    writeFileSync(configPath, content.trim() + '\n', 'utf-8');
+  } catch {
+    p.log.error(`Cannot write to ${configPath}. Check file permissions.`);
+    process.exit(1);
+  }
   p.log.success(`Registered ${agentId} in ~/.codex/config.toml`);
 }
 
@@ -122,7 +172,12 @@ function installOpencode(agentId: string, agentDir: string, isFileTree: boolean)
   const configPath = join(configDir, 'opencode.json');
 
   if (!existsSync(configDir)) {
-    mkdirSync(configDir, { recursive: true });
+    try {
+      mkdirSync(configDir, { recursive: true });
+    } catch {
+      p.log.error(`Cannot create directory ${configDir}. Check permissions.`);
+      process.exit(1);
+    }
   }
 
   let config: Record<string, unknown> = {};
@@ -132,7 +187,10 @@ function installOpencode(agentId: string, agentDir: string, isFileTree: boolean)
       const stripped = raw.replace(/^\s*\/\/.*$/gm, '');
       config = JSON.parse(stripped);
     } catch {
-      config = {};
+      p.log.error(
+        `Failed to parse ${configPath}. The file may be corrupted. Delete it and try again.`,
+      );
+      process.exit(1);
     }
   }
 
@@ -143,21 +201,27 @@ function installOpencode(agentId: string, agentDir: string, isFileTree: boolean)
   const servers = config.mcp as Record<string, unknown>;
   if (isFileTree) {
     const engine = resolveEngineBin();
+    const agentYaml = toPosix(join(agentDir, 'agent.yaml'));
     servers[agentId] = {
       type: 'local',
       command:
         engine.command === 'node'
-          ? ['node', engine.bin, '--agent', join(agentDir, 'agent.yaml')]
-          : ['npx', '-y', '@soleri/engine', '--agent', join(agentDir, 'agent.yaml')],
+          ? ['node', toPosix(engine.bin), '--agent', agentYaml]
+          : ['npx', '-y', '@soleri/engine', '--agent', agentYaml],
     };
   } else {
     servers[agentId] = {
       type: 'local',
-      command: ['node', join(agentDir, 'dist', 'index.js')],
+      command: ['node', toPosix(join(agentDir, 'dist', 'index.js'))],
     };
   }
 
-  writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  try {
+    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n', 'utf-8');
+  } catch {
+    p.log.error(`Cannot write to ${configPath}. Check file permissions.`);
+    process.exit(1);
+  }
   p.log.success(`Registered ${agentId} in ~/.config/opencode/opencode.json`);
 }
 
@@ -172,7 +236,10 @@ function escapeRegExp(s: string): string {
 function installLauncher(agentId: string, agentDir: string): void {
   // Launcher scripts to /usr/local/bin are Unix-only
   if (process.platform === 'win32') {
-    p.log.info('Launcher scripts are not supported on Windows — skipping');
+    p.log.info('Launcher scripts are not supported on Windows.');
+    p.log.info(
+      `On Windows, run your agent with: npx @soleri/cli dev --agent "${toPosix(agentDir)}"`,
+    );
     return;
   }
 
@@ -182,7 +249,7 @@ function installLauncher(agentId: string, agentDir: string): void {
     '#!/bin/bash',
     `# ${agentId} — Soleri second brain launcher`,
     `# Type "${agentId}" from any directory to open Claude Code with this agent`,
-    `exec claude --mcp-config ${join(agentDir, '.mcp.json')}`,
+    `exec claude --mcp-config ${toPosix(join(agentDir, '.mcp.json'))}`,
     '',
   ].join('\n');
 
@@ -192,7 +259,7 @@ function installLauncher(agentId: string, agentDir: string): void {
   } catch {
     p.log.warn(`Could not create launcher at ${binPath} (may need sudo)`);
     p.log.info(
-      `To create manually: sudo bash -c 'cat > ${binPath} << "EOF"\\n#!/bin/bash\\nexec claude --mcp-config ${join(agentDir, '.mcp.json')}\\nEOF' && chmod +x ${binPath}`,
+      `To create manually: sudo bash -c 'cat > ${binPath} << "EOF"\\n#!/bin/bash\\nexec claude --mcp-config ${toPosix(join(agentDir, '.mcp.json'))}\\nEOF' && chmod +x ${binPath}`,
     );
   }
 }

package/src/commands/test.ts

@@ -1,8 +1,139 @@
 import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
 import type { Command } from 'commander';
 import * as p from '@clack/prompts';
+import { parse as parseYaml } from 'yaml';
+import { AgentYamlSchema } from '@soleri/forge/lib';
 import { detectAgent } from '../utils/agent-context.js';
 
+/**
+ * Run validation checks for a file-tree agent (no vitest needed).
+ * Returns the process exit code (0 = all passed, 1 = failures).
+ */
+function runFiletreeChecks(agentPath: string, _agentId: string): number {
+  let passed = 0;
+  let failed = 0;
+  const failures: string[] = [];
+
+  // ── 1. agent.yaml validation ───────────────────────
+  const yamlPath = join(agentPath, 'agent.yaml');
+  try {
+    const raw = readFileSync(yamlPath, 'utf-8');
+    const parsed = parseYaml(raw);
+    const result = AgentYamlSchema.safeParse(parsed);
+    if (result.success) {
+      p.log.success('agent.yaml — valid');
+      passed++;
+    } else {
+      const issues = result.error.issues
+        .map((i) => `  ${i.path.join('.')}: ${i.message}`)
+        .join('\n');
+      p.log.error(`agent.yaml — validation failed\n${issues}`);
+      failures.push('agent.yaml validation');
+      failed++;
+    }
+  } catch (err: unknown) {
+    const msg = err instanceof Error ? err.message : String(err);
+    p.log.error(`agent.yaml — could not read or parse: ${msg}`);
+    failures.push('agent.yaml read/parse');
+    failed++;
+  }
+
+  // ── 2. Skills syntax check ─────────────────────────
+  const skillsDir = join(agentPath, 'skills');
+  if (existsSync(skillsDir)) {
+    let validSkills = 0;
+    let invalidSkills = 0;
+    const invalidNames: string[] = [];
+
+    try {
+      const entries = readdirSync(skillsDir, { withFileTypes: true });
+      const skillDirs = entries.filter((e) => e.isDirectory());
+
+      for (const dir of skillDirs) {
+        const skillMd = join(skillsDir, dir.name, 'SKILL.md');
+        if (!existsSync(skillMd)) {
+          invalidSkills++;
+          invalidNames.push(`${dir.name}: missing SKILL.md`);
+          continue;
+        }
+
+        try {
+          const content = readFileSync(skillMd, 'utf-8');
+          const hasFrontmatter = content.startsWith('---');
+          const hasName = /^name:/m.test(content);
+          const hasDescription = /^description:/m.test(content);
+
+          if (hasFrontmatter && hasName && hasDescription) {
+            validSkills++;
+          } else {
+            invalidSkills++;
+            const missing: string[] = [];
+            if (!hasFrontmatter) missing.push('frontmatter (---)');
+            if (!hasName) missing.push('name:');
+            if (!hasDescription) missing.push('description:');
+            invalidNames.push(`${dir.name}: missing ${missing.join(', ')}`);
+          }
+        } catch {
+          invalidSkills++;
+          invalidNames.push(`${dir.name}: could not read SKILL.md`);
+        }
+      }
+
+      if (invalidSkills === 0) {
+        p.log.success(`skills — ${validSkills} valid, 0 invalid`);
+        passed++;
+      } else {
+        const details = invalidNames.map((n) => `  ${n}`).join('\n');
+        p.log.error(`skills — ${validSkills} valid, ${invalidSkills} invalid\n${details}`);
+        failures.push('skills syntax');
+        failed++;
+      }
+    } catch {
+      p.log.warn('skills — could not read skills/ directory');
+      // Not a failure — directory exists but unreadable is unusual, warn only
+    }
+  } else {
+    p.log.info('skills — no skills/ directory (skipped)');
+  }
+
+  // ── 3. Instructions check ──────────────────────────
+  const instructionsDir = join(agentPath, 'instructions');
+  if (existsSync(instructionsDir)) {
+    try {
+      const files = readdirSync(instructionsDir).filter((f) => f.endsWith('.md'));
+      if (files.length > 0) {
+        p.log.success(`instructions — ${files.length} .md file(s) found`);
+        passed++;
+      } else {
+        p.log.error('instructions — directory exists but contains no .md files');
+        failures.push('instructions empty');
+        failed++;
+      }
+    } catch {
+      p.log.error('instructions — could not read directory');
+      failures.push('instructions read');
+      failed++;
+    }
+  } else {
+    p.log.error('instructions — directory not found');
+    failures.push('instructions missing');
+    failed++;
+  }
+
+  // ── Summary ────────────────────────────────────────
+  if (failed === 0) {
+    p.log.success(`\n${passed} check(s) passed, 0 failed`);
+  } else {
+    p.log.error(
+      `\n${passed} check(s) passed, ${failed} failed:\n${failures.map((f) => `  - ${f}`).join('\n')}`,
+    );
+  }
+
+  return failed > 0 ? 1 : 0;
+}
+
 export function registerTest(program: Command): void {
   program
     .command('test')
@@ -17,6 +148,16 @@ export function registerTest(program: Command): void {
         process.exit(1);
       }
 
+      p.log.info(`Running tests for ${ctx.agentId}...`);
+
+      // ── File-tree agents: run validation checks (no vitest) ──
+      if (ctx.format === 'filetree') {
+        const code = runFiletreeChecks(ctx.agentPath, ctx.agentId);
+        process.exit(code);
+        return;
+      }
+
+      // ── TypeScript agents: spawn vitest as before ──
       const args: string[] = [];
       if (opts.watch) {
         // vitest (no "run") enables watch mode
@@ -30,8 +171,6 @@ export function registerTest(program: Command): void {
       const extra = cmd.args as string[];
       if (extra.length > 0) args.push(...extra);
 
-      p.log.info(`Running tests for ${ctx.agentId}...`);
-
       const child = spawn('npx', args, {
         cwd: ctx.agentPath,
         stdio: 'inherit',

package/src/commands/vault.ts

@@ -0,0 +1,79 @@
+/**
+ * Vault CLI — export vault entries as browsable markdown files.
+ *
+ * `soleri vault export`                     — export to ./knowledge/vault/
+ * `soleri vault export --path ~/obsidian`   — export to custom directory
+ * `soleri vault export --domain arch`       — filter by domain
+ */
+
+import { resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import type { Command } from 'commander';
+import { detectAgent } from '../utils/agent-context.js';
+import * as log from '../utils/logger.js';
+import { SOLERI_HOME } from '@soleri/core';
+
+export function registerVault(program: Command): void {
+  const vault = program.command('vault').description('Vault knowledge management');
+
+  vault
+    .command('export')
+    .description('Export vault entries as browsable markdown files')
+    .option('--path <dir>', 'Output directory (default: ./knowledge/)')
+    .option('--domain <name>', 'Filter by domain')
+    .action(async (opts: { path?: string; domain?: string }) => {
+      const agent = detectAgent();
+      if (!agent) {
+        log.fail('Not in a Soleri agent project', 'Run from an agent directory');
+        process.exit(1);
+      }
+
+      const outputDir = opts.path ? resolve(opts.path) : resolve('knowledge');
+
+      // Find vault DB — check new path first, then legacy
+      const newDbPath = join(SOLERI_HOME, agent.agentId, 'vault.db');
+      const legacyDbPath = join(SOLERI_HOME, '..', `.${agent.agentId}`, 'vault.db');
+      const vaultDbPath = existsSync(newDbPath)
+        ? newDbPath
+        : existsSync(legacyDbPath)
+          ? legacyDbPath
+          : null;
+
+      if (!vaultDbPath) {
+        log.fail('Vault DB not found', 'Run the agent once to initialize its vault database.');
+        process.exit(1);
+      }
+
+      // Dynamic import to avoid loading better-sqlite3 unless needed
+      const { Vault } = await import('@soleri/core');
+      const vaultInstance = new Vault(vaultDbPath);
+
+      try {
+        log.heading('Vault Export');
+
+        if (opts.domain) {
+          const { syncEntryToMarkdown } = await import('@soleri/core');
+          const entries = vaultInstance.list({ limit: 10000, domain: opts.domain });
+          let synced = 0;
+          for (const entry of entries) {
+            await syncEntryToMarkdown(entry, outputDir);
+            synced++;
+          }
+          log.pass(
+            `Exported ${synced} entries from domain "${opts.domain}"`,
+            `${outputDir}/vault/`,
+          );
+        } else {
+          const { syncAllToMarkdown } = await import('@soleri/core');
+          const result = await syncAllToMarkdown(vaultInstance, outputDir);
+          log.pass(
+            `Exported ${result.synced} entries (${result.skipped} unchanged)`,
+            `${outputDir}/vault/`,
+          );
+        }
+      } finally {
+        vaultInstance.close();
+      }
+    });
+}

package/src/hook-packs/flock-guard/manifest.json

@@ -32,5 +32,6 @@
       "timeout": 10,
       "statusMessage": "Releasing lockfile guard..."
     }
-  ]
+  ],
+  "scaffoldDefault": false
 }

package/src/hook-packs/marketing-research/manifest.json

@@ -20,5 +20,6 @@
       "statusMessage": "Checking marketing context..."
     }
   ],
-  "actionLevel": "remind"
+  "actionLevel": "remind",
+  "scaffoldDefault": false
 }

package/src/hook-packs/registry.ts

@@ -31,6 +31,8 @@ export interface HookPackManifest {
   lifecycleHooks?: HookPackLifecycleHook[];
   source?: 'built-in' | 'local';
   actionLevel?: 'remind' | 'warn' | 'block';
+  /** If false, pack is hidden from the scaffold picker but still installable via `hooks add-pack`. */
+  scaffoldDefault?: boolean;
 }
 
 const __filename = fileURLToPath(import.meta.url);

package/src/main.ts

@@ -1,5 +1,13 @@
 #!/usr/bin/env node
 
+const [major] = process.versions.node.split('.').map(Number);
+if (major < 18) {
+  console.error(
+    `\n  Soleri requires Node.js 18 or later.\n  You have v${process.versions.node}.\n  Upgrade at https://nodejs.org\n`,
+  );
+  process.exit(1);
+}
+
 import { createRequire } from 'node:module';
 import { Command } from 'commander';
 import { registerCreate } from './commands/create.js';
@@ -21,6 +29,7 @@ import { registerSkills } from './commands/skills.js';
 import { registerAgent } from './commands/agent.js';
 import { registerTelegram } from './commands/telegram.js';
 import { registerStaging } from './commands/staging.js';
+import { registerVault } from './commands/vault.js';
 import { registerYolo } from './commands/yolo.js';
 
 const require = createRequire(import.meta.url);
@@ -83,5 +92,6 @@ registerSkills(program);
 registerAgent(program);
 registerTelegram(program);
 registerStaging(program);
+registerVault(program);
 registerYolo(program);
 program.parse();

package/src/prompts/create-wizard.ts

@@ -8,6 +8,23 @@
 import * as p from '@clack/prompts';
 import type { AgentConfigInput } from '@soleri/forge/lib';
 import { ITALIAN_CRAFTSPERSON } from '@soleri/core/personas';
+import { isGhInstalled } from '../utils/git.js';
+
+/** Git configuration collected from the wizard. */
+export interface WizardGitConfig {
+  init: boolean;
+  remote?: {
+    type: 'gh' | 'manual';
+    url?: string;
+    visibility?: 'public' | 'private';
+  };
+}
+
+/** Full result from the create wizard. */
+export interface CreateWizardResult {
+  config: AgentConfigInput;
+  git: WizardGitConfig;
+}
 
 /** Slugify a display name into a kebab-case ID. */
 function slugify(name: string): string {
@@ -19,9 +36,9 @@ function slugify(name: string): string {
 
 /**
  * Run the simplified create wizard.
- * Returns an AgentConfigInput or null if cancelled.
+ * Returns a CreateWizardResult or null if cancelled.
  */
-export async function runCreateWizard(initialName?: string): Promise<AgentConfigInput | null> {
+export async function runCreateWizard(initialName?: string): Promise<CreateWizardResult | null> {
   p.intro('Create a new Soleri agent');
 
   // ─── Step 1: Name ───────────────────────────────────────────
@@ -119,17 +136,95 @@ export async function runCreateWizard(initialName?: string): Promise<AgentConfig
 
   if (p.isCancel(confirm) || !confirm) return null;
 
+  // ─── Step 3: Git setup ──────────────────────────────────────
+  const gitInit = await p.confirm({
+    message: 'Initialize as a git repository?',
+    initialValue: true,
+  });
+
+  if (p.isCancel(gitInit)) return null;
+
+  const git: WizardGitConfig = { init: gitInit as boolean };
+
+  if (git.init) {
+    const pushRemote = await p.confirm({
+      message: 'Push to a remote repository?',
+      initialValue: false,
+    });
+
+    if (p.isCancel(pushRemote)) return null;
+
+    if (pushRemote) {
+      const ghAvailable = await isGhInstalled();
+
+      let remoteType: 'gh' | 'manual';
+
+      if (ghAvailable) {
+        const remoteChoice = await p.select({
+          message: 'How would you like to set up the remote?',
+          options: [
+            { value: 'gh' as const, label: 'Create a new GitHub repository' },
+            { value: 'manual' as const, label: 'Add an existing remote URL' },
+          ],
+        });
+
+        if (p.isCancel(remoteChoice)) return null;
+        remoteType = remoteChoice as 'gh' | 'manual';
+      } else {
+        remoteType = 'manual';
+      }
+
+      if (remoteType === 'gh') {
+        const visibility = await p.select({
+          message: 'Repository visibility?',
+          options: [
+            { value: 'private' as const, label: 'Private' },
+            { value: 'public' as const, label: 'Public' },
+          ],
+          initialValue: 'private' as const,
+        });
+
+        if (p.isCancel(visibility)) return null;
+
+        git.remote = {
+          type: 'gh',
+          visibility: visibility as 'public' | 'private',
+        };
+      } else {
+        const remoteUrl = await p.text({
+          message: 'Remote repository URL:',
+          placeholder: 'https://github.com/user/repo.git',
+          validate: (v) => {
+            if (!v || v.trim().length === 0) return 'URL is required';
+            if (!v.startsWith('https://') && !v.startsWith('git@'))
+              return 'URL must start with https:// or git@';
+          },
+        });
+
+        if (p.isCancel(remoteUrl)) return null;
+
+        git.remote = {
+          type: 'manual',
+          url: (remoteUrl as string).trim(),
+        };
+      }
+    }
+  }
+
   return {
-    id,
-    name: name.trim(),
-    role: 'Your universal second brain — learns, remembers, improves',
-    description:
-      'A universal assistant that learns from your projects, captures knowledge, and gets smarter with every session.',
-    domains: [],
-    principles: [],
-    skills: [],
-    tone: 'mentor',
-    greeting,
-    persona,
-  } as AgentConfigInput;
+    config: {
+      id,
+      name: name.trim(),
+      role: 'Your universal second brain — learns, remembers, improves',
+      description:
+        'A universal assistant that learns from your projects, captures knowledge, and gets smarter with every session.',
+      domains: [],
+      principles: [],
+      skills: [],
+      tone: 'mentor',
+      greeting,
+      persona,
+    } as AgentConfigInput,
+    git,
+  };
 }