a2acalling 0.6.2 → 0.6.3

package/SKILL.md

@@ -96,7 +96,7 @@ Deterministic onboarding flow (sequential, flags-based):
 
 1. Background bootstrap (config + disclosure)
 2. Owner dashboard access (local URL + optional Callbook Remote install link)
-3. Set permission tiers: populate and confirm tier `topics` + `goals`
+3. Set permission tiers: populate tier `topics` + `goals` (schema-validated and saved)
 4. Port scan + reverse proxy guidance (if needed for public hostname)
 5. External IP confirmation and public reachability check (public hostname only)
 
@@ -110,12 +110,14 @@ a2a quickstart --port 3001
 a2a quickstart --hostname YOUR_DOMAIN:443 --port 3001
 ```
 
-Quickstart will print a proposed tier configuration. After the user reviews it, re-run with:
+Quickstart prints and saves a tier configuration immediately (validated by the config layer). If you want to override the Friends tier topics/interests, rerun with:
 
 ```bash
-a2a quickstart --port 3001 --confirm-tiers
-# or (public hostname)
-a2a quickstart --hostname YOUR_DOMAIN:443 --port 3001 --confirm-tiers
+# Provide topics directly
+a2a quickstart --port 3001 --friends-topics "chat,search,openclaw,a2a"
+
+# Or prompt interactively for Friends tier topics
+a2a quickstart --port 3001 --interactive
 ```
 
 If reverse proxy/ingress is required, Quickstart will stop and ask for explicit confirmation (`--confirm-ingress`).

package/bin/cli.js

@@ -1105,19 +1105,26 @@ https://github.com/onthegonow/a2a_calling`;
     // ── Step 1: Background bootstrap (config + manifest) ─────────
     let contextFiles = {};
     let manifest = {};
-    try {
-      contextFiles = disc.readContextFiles(workspaceDir);
-      manifest = disc.loadManifest();
-      if (!manifest || Object.keys(manifest).length === 0) {
-        const generated = disc.generateDefaultManifest(contextFiles);
-        disc.saveManifest(generated);
-        manifest = generated;
-      }
-    } catch (err) {
-      // Non-fatal: onboarding can proceed even if manifest fails.
-      contextFiles = {};
-      manifest = {};
-    }
+	    try {
+	      contextFiles = disc.readContextFiles(workspaceDir);
+	      const forceManifest = Boolean(args.flags.force || args.flags['regen-manifest'] || args.flags.regenManifest);
+	      if (forceManifest) {
+	        const generated = disc.generateDefaultManifest(contextFiles);
+	        disc.saveManifest(generated);
+	        manifest = generated;
+	      } else {
+	        manifest = disc.loadManifest();
+	        if (!manifest || Object.keys(manifest).length === 0) {
+	          const generated = disc.generateDefaultManifest(contextFiles);
+	          disc.saveManifest(generated);
+	          manifest = generated;
+	        }
+	      }
+	    } catch (err) {
+	      // Non-fatal: onboarding can proceed even if manifest fails.
+	      contextFiles = {};
+	      manifest = {};
+	    }
 
     console.log('\nA2A deterministic onboarding');
     console.log('──────────────────────────');
@@ -1180,32 +1187,84 @@ https://github.com/onthegonow/a2a_calling`;
       }
     }
 
-    // ── Step 3: Permission tiers (topics + goals) ───────────────
-    const onboardingAfterAccess = config.getOnboarding();
-    if (!onboardingAfterAccess.tiers_confirmed) {
-      const recommendations = buildTierRecommendations(contextFiles, manifest);
+	    // ── Step 3: Permission tiers (topics + goals) ───────────────
+	    const onboardingAfterAccess = config.getOnboarding();
+	    if (!onboardingAfterAccess.tiers_confirmed) {
+	      const recommendations = buildTierRecommendations(contextFiles, manifest);
+
+	      const parseFreeTextList = (raw) => {
+	        if (raw === undefined || raw === null || raw === true) return [];
+	        const text = String(raw || '').trim();
+	        if (!text) return [];
+	        return text
+	          .split(/[\n,]+/g)
+	          .map(s => s.trim())
+	          .filter(Boolean);
+	      };
+
+	      const promptLine = async (question) => {
+	        const readline = require('readline');
+	        return await new Promise(resolve => {
+	          const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+	          rl.question(question, (answer) => {
+	            rl.close();
+	            resolve(String(answer || '').trim());
+	          });
+	        });
+	      };
+
+	      // Optional owner override: Friends tier topics/interests (most important tier).
+	      const interactive = Boolean(
+	        args.flags.interactive ||
+	        args.flags['ask-friends-topics'] ||
+	        args.flags.askFriendsTopics
+	      );
+	      let friendsTopicsOverride = parseFreeTextList(args.flags['friends-topics'] || args.flags.friendsTopics);
+	      const noWorkspaceContext = !contextFiles.user && !contextFiles.heartbeat && !contextFiles.soul &&
+	        !contextFiles.memory && !contextFiles.claude;
+	      const shouldPromptFriendsTopics = (interactive || noWorkspaceContext) &&
+	        friendsTopicsOverride.length === 0 &&
+	        process.stdin.isTTY &&
+	        process.stdout.isTTY;
+	      if (shouldPromptFriendsTopics) {
+	        const suggested = (recommendations.friends.topics || []).slice(0, 12).join(', ');
+	        const answer = await promptLine(`Friends-tier topics/interests (comma-separated).\nSuggested: ${suggested}\n> `);
+	        friendsTopicsOverride = parseFreeTextList(answer);
+	      }
 
-      config.setTier('public', recommendations.public);
-      config.setTier('friends', recommendations.friends);
-      config.setTier('family', recommendations.family);
+	      if (friendsTopicsOverride.length > 0) {
+	        const normalized = uniqueNonEmpty(friendsTopicsOverride.map(slugify).filter(Boolean), 24);
+	        recommendations.friends.topics = uniqueNonEmpty(
+	          [...(recommendations.public.topics || []), ...normalized],
+	          24
+	        );
+	        recommendations.family.topics = uniqueNonEmpty(
+	          [...(recommendations.friends.topics || []), ...(recommendations.family.topics || [])],
+	          30
+	        );
+	      }
 
-      printTierSummary(recommendations);
+	      try {
+	        config.setTier('public', recommendations.public);
+	        config.setTier('friends', recommendations.friends);
+	        config.setTier('family', recommendations.family);
+	      } catch (err) {
+	        console.error('\n❌ Tier configuration validation failed.');
+	        console.error(`   ${err.message}`);
+	        if (err.hint) {
+	          console.error(`   Hint: ${err.hint}`);
+	        }
+	        console.error('');
+	        process.exit(1);
+	      }
 
-      if (!args.flags['confirm-tiers']) {
-        console.log('3️⃣  Confirm tiers');
-        console.log('Review the topics/goals above. To confirm and continue, run:');
-        console.log(`  a2a quickstart --port ${backendPort} --confirm-tiers`);
-        console.log('Optional (remote access):');
-        console.log(`  a2a quickstart --hostname YOUR_DOMAIN:443 --port ${backendPort} --confirm-tiers`);
-        console.log('');
-        return;
-      }
+	      printTierSummary(recommendations);
 
-      config.setOnboarding({
-        step: 'tiers',
-        tiers_confirmed: true
-      });
-    }
+	      config.setOnboarding({
+	        step: 'tiers',
+	        tiers_confirmed: true
+	      });
+	    }
 
     // ── Step 4: Port scan + reverse proxy guidance (if needed) ──
     console.log('\n4️⃣  Port scan + reverse proxy');
@@ -1239,13 +1298,13 @@ https://github.com/onthegonow/a2a_calling`;
       console.log(`  /api/a2a/*   -> http://127.0.0.1:${backendPort}`);
       console.log(`  /dashboard/* -> http://127.0.0.1:${backendPort}`);
       console.log(`  /callbook/*  -> http://127.0.0.1:${backendPort}`);
-      console.log('');
-      console.log('If you have configured your reverse proxy and want to continue, run:');
-      console.log(`  a2a quickstart --hostname ${inviteHost} --port ${backendPort} --confirm-tiers --confirm-ingress`);
-      console.log('');
-      if (!args.flags['confirm-ingress']) {
-        return;
-      }
+	      console.log('');
+	      console.log('If you have configured your reverse proxy and want to continue, run:');
+	      console.log(`  a2a quickstart --hostname ${inviteHost} --port ${backendPort} --confirm-ingress`);
+	      console.log('');
+	      if (!args.flags['confirm-ingress']) {
+	        return;
+	      }
     } else {
       console.log('✅ No reverse proxy required based on invite host/port.');
     }
@@ -1299,13 +1358,13 @@ https://github.com/onthegonow/a2a_calling`;
       const extPing = await externalPingCheck(expectedPingUrl);
       if (extPing.ok) {
         console.log(`✅ External ping OK (${extPing.provider})`);
-      } else if (!args.flags['skip-verify']) {
-        console.log('⚠️  External ping FAILED (server may not be publicly reachable yet).');
-        console.log('Fix ingress (DNS/reverse proxy/firewall), then rerun with:');
-        console.log(`  a2a quickstart --hostname ${inviteHost} --port ${backendPort} --confirm-tiers --confirm-ingress`);
-        console.log('');
-        return;
-      } else {
+	      } else if (!args.flags['skip-verify']) {
+	        console.log('⚠️  External ping FAILED (server may not be publicly reachable yet).');
+	        console.log('Fix ingress (DNS/reverse proxy/firewall), then rerun with:');
+	        console.log(`  a2a quickstart --hostname ${inviteHost} --port ${backendPort} --confirm-ingress`);
+	        console.log('');
+	        return;
+	      } else {
         console.log('⚠️  External ping FAILED (skipped via --skip-verify).');
       }
     }
@@ -1453,15 +1512,14 @@ https://github.com/onthegonow/a2a_calling`;
 
     const contextFiles = readContextFiles(workspaceDir);
     // Print what was found
-    const sources = {
-      'USER.md': contextFiles.user,
-      'HEARTBEAT.md': contextFiles.heartbeat,
-      'SOUL.md': contextFiles.soul,
-      'SKILL.md': contextFiles.skill,
-      'CLAUDE.md': contextFiles.claude,
-      'memory/*.md': contextFiles.memory,
-      'Installed skills': contextFiles.skills
-    };
+	    const sources = {
+	      'USER.md': contextFiles.user,
+	      'HEARTBEAT.md': contextFiles.heartbeat,
+	      'SOUL.md': contextFiles.soul,
+	      'SKILL.md': contextFiles.skill,
+	      'CLAUDE.md': contextFiles.claude,
+	      'memory/*.md': contextFiles.memory
+	    };
     for (const [name, content] of Object.entries(sources)) {
       console.log(`   ${content ? '\u2705' : '\u274c'} ${name}`);
     }
@@ -1537,14 +1595,16 @@ Server:
   server              Start the A2A server
     --port, -p        Port to listen on (default: 3001)
   
-  quickstart          Deterministic onboarding (access → tiers → ingress → verify)
+  quickstart          Onboarding (access → tiers → ingress → verify)
     --hostname        Public hostname for remote access (e.g. myserver.com:443)
     --public-port     Port to assume when --hostname omits a port (default: 443)
     --port            A2A server port to run locally (default: 3001)
-    --confirm-tiers   Confirm tier topics/goals and continue
+    --friends-topics  Override Friends tier topics/interests (comma or newline-separated)
+    --interactive     Prompt for Friends tier topics if needed
     --confirm-ingress Confirm reverse proxy/ingress is configured and continue
     --skip-verify     Skip external reachability check (not recommended)
-    --force           Reset onboarding and start over
+    --force           Reset onboarding + regenerate disclosure manifest
+    --regen-manifest  Regenerate disclosure manifest (no onboarding reset)
   
   onboard             Generate disclosure manifest from workspace context
     --force           Re-run even if already onboarded

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "a2acalling",
-  "version": "0.6.2",
+  "version": "0.6.3",
   "description": "Agent-to-agent calling for OpenClaw - A2A agent communication",
   "main": "src/index.js",
   "bin": {

package/src/lib/config.js

@@ -15,6 +15,140 @@ const CONFIG_DIR = process.env.A2A_CONFIG_DIR ||
 const CONFIG_FILE = path.join(CONFIG_DIR, 'a2a-config.json');
 const logger = createLogger({ component: 'a2a.config' });
 
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function configValidationError(code, message, hint, data) {
+  const err = new Error(message);
+  err.code = code;
+  if (hint) err.hint = hint;
+  if (data) err.data = data;
+  return err;
+}
+
+function sanitizeString(value, maxLength = 200) {
+  return String(value || '')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, maxLength);
+}
+
+function validateStringArray(value, label, options = {}) {
+  const maxItems = Number.isFinite(options.maxItems) ? options.maxItems : 200;
+  const itemMaxLength = Number.isFinite(options.itemMaxLength) ? options.itemMaxLength : 160;
+
+  if (!Array.isArray(value)) {
+    throw configValidationError(
+      'A2A_CONFIG_INVALID_ARRAY',
+      `Invalid ${label}: expected an array of strings`,
+      'Pass an array like ["chat","search"].',
+      { label, received_type: typeof value }
+    );
+  }
+
+  const unique = [];
+  const seen = new Set();
+  for (const entry of value) {
+    if (typeof entry !== 'string') {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_ARRAY_ITEM',
+        `Invalid ${label}: each item must be a string`,
+        'Ensure your tier topics/goals are string arrays.',
+        { label, received_item_type: typeof entry }
+      );
+    }
+    const cleaned = sanitizeString(entry, itemMaxLength);
+    if (!cleaned) continue;
+    const key = cleaned.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    unique.push(cleaned);
+    if (unique.length >= maxItems) break;
+  }
+
+  return unique;
+}
+
+function validateTierPatch(tierName, tierConfig) {
+  if (!isPlainObject(tierConfig)) {
+    throw configValidationError(
+      'A2A_CONFIG_INVALID_TIER_PATCH',
+      `Invalid tier config for "${tierName}": expected an object`,
+      'Pass an object like { topics: [...], goals: [...] }.',
+      { tier: tierName, received_type: typeof tierConfig }
+    );
+  }
+
+  const out = {};
+
+  if (tierConfig.name !== undefined) {
+    if (typeof tierConfig.name !== 'string') {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_TIER_NAME',
+        `Invalid tier name for "${tierName}": expected string`,
+        null,
+        { tier: tierName, received_type: typeof tierConfig.name }
+      );
+    }
+    out.name = sanitizeString(tierConfig.name, 120);
+  }
+
+  if (tierConfig.description !== undefined) {
+    if (typeof tierConfig.description !== 'string') {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_TIER_DESCRIPTION',
+        `Invalid tier description for "${tierName}": expected string`,
+        null,
+        { tier: tierName, received_type: typeof tierConfig.description }
+      );
+    }
+    out.description = sanitizeString(tierConfig.description, 300);
+  }
+
+  if (tierConfig.disclosure !== undefined) {
+    if (typeof tierConfig.disclosure !== 'string') {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_TIER_DISCLOSURE',
+        `Invalid tier disclosure for "${tierName}": expected string`,
+        null,
+        { tier: tierName, received_type: typeof tierConfig.disclosure }
+      );
+    }
+    out.disclosure = sanitizeString(tierConfig.disclosure, 40) || 'minimal';
+  }
+
+  if (tierConfig.capabilities !== undefined) {
+    out.capabilities = validateStringArray(tierConfig.capabilities, `${tierName}.capabilities`, {
+      maxItems: 100,
+      itemMaxLength: 120
+    });
+  }
+
+  if (tierConfig.topics !== undefined) {
+    out.topics = validateStringArray(tierConfig.topics, `${tierName}.topics`, {
+      maxItems: 200,
+      itemMaxLength: 160
+    });
+  }
+
+  if (tierConfig.goals !== undefined) {
+    out.goals = validateStringArray(tierConfig.goals, `${tierName}.goals`, {
+      maxItems: 200,
+      itemMaxLength: 160
+    });
+  }
+
+  if (tierConfig.examples !== undefined) {
+    out.examples = validateStringArray(tierConfig.examples, `${tierName}.examples`, {
+      maxItems: 20,
+      itemMaxLength: 120
+    });
+  }
+
+  return out;
+}
+
 function deepMerge(base, override) {
   const baseIsObject = base && typeof base === 'object' && !Array.isArray(base);
   const overrideIsObject = override && typeof override === 'object' && !Array.isArray(override);
@@ -206,7 +340,19 @@ class A2AConfig {
   }
 
   setTier(tierName, tierConfig) {
-    this.config.tiers[tierName] = { ...this.config.tiers[tierName], ...tierConfig };
+    const id = String(tierName || '').trim();
+    if (!id) {
+      throw configValidationError(
+        'A2A_CONFIG_INVALID_TIER_ID',
+        'Tier name is required',
+        'Use one of: public|friends|family|custom (or a non-empty custom tier id).'
+      );
+    }
+
+    const patch = validateTierPatch(id, tierConfig);
+    this.config.tiers = isPlainObject(this.config.tiers) ? this.config.tiers : {};
+    const existing = isPlainObject(this.config.tiers[id]) ? this.config.tiers[id] : {};
+    this.config.tiers[id] = { ...existing, ...patch };
     this._save();
   }
 

package/src/lib/conversations.js

@@ -47,6 +47,7 @@ class ConversationStore {
         // Best effort - ignore on platforms without chmod support.
       }
       this._migrate();
+      this._ensureLatestSchema(Database);
       return this.db;
     } catch (err) {
       if (err.code === 'MODULE_NOT_FOUND') {
@@ -128,6 +129,79 @@ class ConversationStore {
     `);
   }
 
+  _ensureLatestSchema(Database) {
+    // Prototype-mode stance: do not attempt in-place migrations.
+    // If schema is missing required columns, back up and recreate the DB.
+    try {
+      const info = this.db.prepare('PRAGMA table_info(conversations)').all();
+      if (!Array.isArray(info) || info.length === 0) {
+        return;
+      }
+      const cols = new Set(info.map(row => row && row.name).filter(Boolean));
+      const required = [
+        'joint_action_items',
+        'collaboration_opportunity'
+      ];
+      const missing = required.filter(c => !cols.has(c));
+      if (missing.length === 0) {
+        return;
+      }
+
+      const backupPath = `${this.dbPath}.bak.${Date.now()}`;
+      logger.warn('Conversation DB schema mismatch; resetting to latest schema', {
+        event: 'conversation_db_schema_reset',
+        data: {
+          db_path: this.dbPath,
+          backup_path: backupPath,
+          missing_columns: missing
+        }
+      });
+
+      try { this.db.close(); } catch (_) {}
+      this.db = null;
+
+      try {
+        fs.renameSync(this.dbPath, backupPath);
+      } catch (err) {
+        try {
+          fs.copyFileSync(this.dbPath, backupPath);
+          fs.unlinkSync(this.dbPath);
+        } catch (err2) {
+          // If we can't move the old DB out of the way, keep going without resetting.
+          logger.error('Failed to back up conversations DB for schema reset', {
+            event: 'conversation_db_schema_reset_backup_failed',
+            error: err2,
+            error_code: 'CONVERSATION_DB_SCHEMA_RESET_BACKUP_FAILED',
+            hint: 'Check file permissions on a2a-conversations.db and ensure the process can rename/unlink it.',
+            data: {
+              db_path: this.dbPath,
+              backup_path: backupPath
+            }
+          });
+          const reopen = new Database(this.dbPath);
+          this.db = reopen;
+          return;
+        }
+      }
+
+      this.db = new Database(this.dbPath);
+      try {
+        fs.chmodSync(this.dbPath, 0o600);
+      } catch (err) {
+        // Best effort.
+      }
+      this._migrate();
+    } catch (err) {
+      // Best effort: leave existing DB in place if schema validation fails unexpectedly.
+      logger.error('Conversation DB schema validation failed', {
+        event: 'conversation_db_schema_validation_failed',
+        error: err,
+        error_code: 'CONVERSATION_DB_SCHEMA_VALIDATION_FAILED',
+        hint: 'If this persists, delete ~/.config/openclaw/a2a-conversations.db (prototype mode) and restart.'
+      });
+    }
+  }
+
   /**
    * Generate a conversation ID (shared between both agents)
    */

package/src/lib/disclosure.js

@@ -146,7 +146,7 @@ function generateDefaultManifest(contextFiles = {}) {
   const soulContent = contextFiles.soul || '';
 
   const hasContent = userContent || heartbeatContent || soulContent ||
-    contextFiles.skill || contextFiles.memory || contextFiles.skills || contextFiles.claude;
+    contextFiles.memory || contextFiles.claude;
 
   if (!hasContent) {
     // Minimal starter manifest
@@ -263,21 +263,6 @@ function generateDefaultManifest(contextFiles = {}) {
     }
   }
 
-  // Extract capability keywords from SKILL.md and installed skills
-  const skillContent = (contextFiles.skill || '') + '\n' + (contextFiles.skills || '');
-  if (skillContent.trim()) {
-    const capabilityLines = skillContent
-      .split('\n')
-      .filter(l => l.trim().startsWith('-') || l.trim().startsWith('*'))
-      .map(l => l.replace(/^[\s\-\*]+/, '').trim())
-      .filter(l => l.length > 5 && l.length < 120)
-      .slice(0, 6);
-
-    capabilityLines.forEach(cap => {
-      manifest.topics.public.discuss_freely.push({ topic: cap.slice(0, 60), detail: cap });
-    });
-  }
-
   // Extract topic keywords from memory files
   if (contextFiles.memory) {
     const memoryLines = contextFiles.memory
@@ -350,7 +335,8 @@ function readContextFiles(workspaceDir) {
     heartbeat: read('HEARTBEAT.md'),
     soul: read('SOUL.md'),
     skill: read('SKILL.md'),
-    claude: read('CLAUDE.md')
+    claude: read('CLAUDE.md'),
+    skills: ''
   };
 
   // Scan memory/*.md
@@ -366,32 +352,6 @@ function readContextFiles(workspaceDir) {
     } catch (e) {}
   }
 
-  // Scan installed skills from both OpenClaw and standalone paths
-  const homeDir = process.env.HOME || '/tmp';
-  const skillsDirs = [
-    process.env.OPENCLAW_SKILLS || path.join(homeDir, '.openclaw', 'skills'),
-    path.join(CONFIG_DIR, 'skills')
-  ];
-  const skillFragments = [];
-  const seenSkillDirs = new Set();
-  for (const skillsDir of skillsDirs) {
-    if (!fs.existsSync(skillsDir) || seenSkillDirs.has(skillsDir)) continue;
-    seenSkillDirs.add(skillsDir);
-    try {
-      const dirs = fs.readdirSync(skillsDir).filter(d => {
-        try { return fs.statSync(path.join(skillsDir, d)).isDirectory(); }
-        catch (e) { return false; }
-      });
-      for (const d of dirs) {
-        try {
-          const content = fs.readFileSync(path.join(skillsDir, d, 'SKILL.md'), 'utf8');
-          if (content) skillFragments.push(content);
-        } catch (e) {}
-      }
-    } catch (e) {}
-  }
-  result.skills = skillFragments.join('\n---\n');
-
   return result;
 }
 

package/src/routes/dashboard.js

@@ -1069,7 +1069,16 @@ function createDashboardApiRouter(options = {}) {
     if (body.topics !== undefined) update.topics = sanitizeStringArray(body.topics, 200, 160);
     if (body.goals !== undefined) update.goals = sanitizeStringArray(body.goals, 200, 160);
 
-    context.config.setTier(tierId, update);
+    try {
+      context.config.setTier(tierId, update);
+    } catch (err) {
+      return res.status(400).json({
+        success: false,
+        error: 'invalid_tier_config',
+        code: err.code || 'A2A_CONFIG_INVALID_TIER_CONFIG',
+        message: err.message
+      });
+    }
 
     if (body.manifest) {
       const manifest = loadManifest();
@@ -1099,17 +1108,35 @@ function createDashboardApiRouter(options = {}) {
 
     const copyFrom = normalizeTierId(body.copy_from || '');
     if (copyFrom && cfg.tiers && cfg.tiers[copyFrom]) {
-      context.config.setTier(tierId, { ...cfg.tiers[copyFrom] });
+      try {
+        context.config.setTier(tierId, { ...cfg.tiers[copyFrom] });
+      } catch (err) {
+        return res.status(400).json({
+          success: false,
+          error: 'invalid_tier_config',
+          code: err.code || 'A2A_CONFIG_INVALID_TIER_CONFIG',
+          message: err.message
+        });
+      }
     } else {
-      context.config.setTier(tierId, {
-        name: sanitizeString(body.name || tierId, 120),
-        description: sanitizeString(body.description || 'Custom tier', 300),
-        capabilities: sanitizeStringArray(body.capabilities || []),
-        topics: sanitizeStringArray(body.topics || []),
-        goals: sanitizeStringArray(body.goals || []),
-        disclosure: sanitizeString(body.disclosure || 'minimal', 40),
-        examples: sanitizeStringArray(body.examples || [], 20, 120)
-      });
+      try {
+        context.config.setTier(tierId, {
+          name: sanitizeString(body.name || tierId, 120),
+          description: sanitizeString(body.description || 'Custom tier', 300),
+          capabilities: sanitizeStringArray(body.capabilities || []),
+          topics: sanitizeStringArray(body.topics || []),
+          goals: sanitizeStringArray(body.goals || []),
+          disclosure: sanitizeString(body.disclosure || 'minimal', 40),
+          examples: sanitizeStringArray(body.examples || [], 20, 120)
+        });
+      } catch (err) {
+        return res.status(400).json({
+          success: false,
+          error: 'invalid_tier_config',
+          code: err.code || 'A2A_CONFIG_INVALID_TIER_CONFIG',
+          message: err.message
+        });
+      }
     }
 
     return res.json({ success: true, tier_id: tierId });
@@ -1127,7 +1154,16 @@ function createDashboardApiRouter(options = {}) {
       return res.status(404).json({ success: false, error: 'source_tier_not_found' });
     }
 
-    context.config.setTier(toTier, { ...cfg.tiers[fromTier] });
+    try {
+      context.config.setTier(toTier, { ...cfg.tiers[fromTier] });
+    } catch (err) {
+      return res.status(400).json({
+        success: false,
+        error: 'invalid_tier_config',
+        code: err.code || 'A2A_CONFIG_INVALID_TIER_CONFIG',
+        message: err.message
+      });
+    }
 
     const manifest = loadManifest();
     if (manifest.topics && manifest.topics[fromTier]) {