@mndrk/agx 2.0.32 → 2.0.34

package/cloud-runtime/standalone/lib/skills-library.ts

@@ -0,0 +1,450 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import type { ChatProvider, SkillBinding } from "./types";
+import { getSQLiteDb } from "./sqlite-query-adapter";
+
+export type SkillsCatalogEntry = {
+  rank: number;
+  name: string;
+  skillId: string;
+  repo: string;
+  installs: number;
+};
+
+export type SkillDetail = {
+  title: string;
+  description: string;
+  whenToUse: string[];
+  weeklyInstalls: string;
+  firstSeen: string;
+  installCommand: string;
+};
+
+export type SkillHistoryRow = {
+  id: string;
+  provider: ChatProvider | "unknown";
+  repo: string;
+  skill_id: string;
+  skill_label: string;
+  status: "running" | "succeeded" | "failed";
+  command: string;
+  error: string | null;
+  run_started_at: number | null;
+  run_completed_at: number | null;
+  created_at: number;
+  updated_at: number;
+};
+
+const SKILLS_CACHE_TTL = 60 * 60 * 1000;
+const SKILL_DETAIL_CACHE_TTL = 60 * 60 * 1000;
+const SUPPORTED_SKILL_PROVIDERS: ChatProvider[] = ["claude", "codex", "gemini", "zai"];
+
+let cachedSkills: { loadedAt: number; data: SkillsCatalogEntry[] } | null = null;
+const skillDetailCache = new Map<string, { loadedAt: number; data: SkillDetail }>();
+
+function collapseWhitespace(input: string): string {
+  return input.replace(/\s+/g, " ").trim();
+}
+
+function decodeHtmlEntities(input: string): string {
+  return input
+    .replace(/&#x([0-9a-f]+);/gi, (_m, hex: string) => {
+      const code = Number.parseInt(hex, 16);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : _m;
+    })
+    .replace(/&#([0-9]+);/g, (_m, dec: string) => {
+      const code = Number.parseInt(dec, 10);
+      return Number.isFinite(code) ? String.fromCodePoint(code) : _m;
+    })
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'")
+    .replace(/&#39;/g, "'")
+    .replace(/&lt;/g, "<")
+    .replace(/&gt;/g, ">")
+    .replace(/&amp;/g, "&")
+    .replace(/&nbsp;/g, " ");
+}
+
+function stripHtml(input: string): string {
+  return decodeHtmlEntities(
+    input
+      .replace(/<br\s*\/?>/gi, "\n")
+      .replace(/<\/(p|h1|h2|h3|h4|h5|h6|li|tr|div)>/gi, "\n")
+      .replace(/<li[^>]*>/gi, "• ")
+      .replace(/<[^>]*>/g, "")
+  )
+    .replace(/\r/g, "")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function extractProseContent(html: string): string {
+  const strictMatch = html.match(
+    /<div class="prose[^>]*>([\s\S]*?)<\/div>\s*<\/div>\s*<\/div>\s*<\/div>\s*<div class=" lg:col-span-3">/i
+  );
+  if (strictMatch?.[1]) return strictMatch[1];
+
+  const proseStart = html.indexOf('<div class="prose');
+  if (proseStart === -1) return "";
+  const innerStart = html.indexOf(">", proseStart);
+  if (innerStart === -1) return "";
+  const rightColStart = html.indexOf('<div class=" lg:col-span-3">', innerStart);
+  if (rightColStart === -1) return "";
+  return html.slice(innerStart + 1, rightColStart).replace(/\s*<\/div>\s*$/i, "").trim();
+}
+
+function normalizeSkillLearnProvider(provider: string): ChatProvider | null {
+  if (provider === "claude" || provider === "codex" || provider === "gemini" || provider === "zai") {
+    return provider;
+  }
+  return null;
+}
+
+function skillAgentName(provider: ChatProvider): string | null {
+  if (provider === "claude") return "claude-code";
+  if (provider === "codex") return "codex";
+  if (provider === "gemini") return "gemini-cli";
+  if (provider === "zai") return "claude-code";
+  return null;
+}
+
+export function supportedSkillProviders(): ChatProvider[] {
+  return SUPPORTED_SKILL_PROVIDERS;
+}
+
+export function installedSkillPath(skillId: string): string {
+  return path.join(process.cwd(), ".agents", "skills", skillId, "SKILL.md");
+}
+
+export function bindingToInstalledPath(binding: SkillBinding): string {
+  return installedSkillPath(binding.skillId);
+}
+
+export function listInstalledSkillIds(): string[] {
+  const root = path.join(process.cwd(), ".agents", "skills");
+  if (!fs.existsSync(root)) return [];
+  return fs
+    .readdirSync(root, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory() && fs.existsSync(path.join(root, entry.name, "SKILL.md")))
+    .map((entry) => entry.name)
+    .sort((a, b) => a.localeCompare(b));
+}
+
+export async function fetchSkillsCatalog(): Promise<SkillsCatalogEntry[]> {
+  if (cachedSkills && Date.now() - cachedSkills.loadedAt < SKILLS_CACHE_TTL) {
+    return cachedSkills.data;
+  }
+
+  try {
+    const response = await fetch("https://skills.sh");
+    if (!response.ok) return [];
+    const html = await response.text();
+    const anchor = html.indexOf("initialSkills");
+    if (anchor === -1) return [];
+    const bracketStart = html.indexOf(":[", anchor);
+    if (bracketStart === -1) return [];
+    const arrStart = bracketStart + 1;
+
+    let depth = 0;
+    let arrEnd = arrStart;
+    for (let i = arrStart; i < html.length; i += 1) {
+      if (html[i] === "[") depth += 1;
+      if (html[i] === "]") depth -= 1;
+      if (depth === 0) {
+        arrEnd = i + 1;
+        break;
+      }
+    }
+
+    const raw = html.slice(arrStart, arrEnd).replace(/\\"/g, '"');
+    const items = JSON.parse(raw) as Array<{ source?: string; skillId?: string; name?: string; installs?: number }>;
+    const skills = items.map((obj, index) => ({
+      rank: index + 1,
+      name: obj.name ?? obj.skillId ?? "",
+      skillId: obj.skillId ?? obj.name ?? "",
+      repo: obj.source ?? "",
+      installs: typeof obj.installs === "number" ? obj.installs : 0,
+    }));
+
+    cachedSkills = { loadedAt: Date.now(), data: skills };
+    return skills;
+  } catch {
+    return [];
+  }
+}
+
+export async function fetchSkillDetail(source: string, skillId: string): Promise<SkillDetail | null> {
+  const cacheKey = `${source}/${skillId}`;
+  const cached = skillDetailCache.get(cacheKey);
+  if (cached && Date.now() - cached.loadedAt < SKILL_DETAIL_CACHE_TTL) {
+    return cached.data;
+  }
+
+  try {
+    const response = await fetch(`https://skills.sh/${source}/${skillId}`);
+    if (!response.ok) return null;
+    const html = await response.text();
+    const proseContent = extractProseContent(html);
+    const titleMatch = proseContent.match(/<h1[^>]*>([\s\S]*?)<\/h1>/i);
+    const title = titleMatch ? collapseWhitespace(stripHtml(titleMatch[1])) : "";
+    const afterTitle = titleMatch ? proseContent.slice((titleMatch.index ?? 0) + titleMatch[0].length) : proseContent;
+    const firstParagraphMatch = afterTitle.match(/<p[^>]*>([\s\S]*?)<\/p>/i);
+    const description = firstParagraphMatch ? collapseWhitespace(stripHtml(firstParagraphMatch[1])) : "";
+
+    const whenToUse: string[] = [];
+    const whenSectionMatch = proseContent.match(/<h2[^>]*>\s*When to Use This Skill\s*<\/h2>([\s\S]*?)(?:<h2[^>]*>|$)/i);
+    if (whenSectionMatch) {
+      const listMatch = whenSectionMatch[1].match(/<ul[^>]*>([\s\S]*?)<\/ul>/i);
+      if (listMatch) {
+        const liRegex = /<li[^>]*>([\s\S]*?)<\/li>/gi;
+        let li: RegExpExecArray | null = null;
+        while ((li = liRegex.exec(listMatch[1])) !== null) {
+          const item = collapseWhitespace(stripHtml(li[1]));
+          if (item) whenToUse.push(item);
+        }
+      }
+    }
+
+    const weeklyInstalls = html.match(/Weekly\s+Installs[\s\S]{0,240}?>([\d,.]+[KkMm]?)<\/div>/i)?.[1] ?? "";
+    const firstSeen = html.match(/First\s+[Ss]een[\s\S]{0,240}?>([A-Za-z]{3}\s+\d{1,2},\s+\d{4})<\/div>/i)?.[1] ?? "";
+    const commandMatch = html.match(/\\"command\\":\\"((?:[^"\\]|\\.)*)\\"/);
+    const installCommand = commandMatch
+      ? commandMatch[1].replace(/\\"/g, '"').replace(/\\\\/g, "\\").trim()
+      : `npx skills add ${source} --skill ${skillId}`;
+
+    const detail = { title, description, whenToUse, weeklyInstalls, firstSeen, installCommand };
+    skillDetailCache.set(cacheKey, { loadedAt: Date.now(), data: detail });
+    return detail;
+  } catch {
+    return null;
+  }
+}
+
+function recordSkillHistory(input: Omit<SkillHistoryRow, "id">): void {
+  const db = getSQLiteDb();
+  db.prepare(
+    `INSERT INTO skill_learning_history
+      (provider, repo, skill_id, skill_label, status, command, error, run_started_at, run_completed_at, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+  ).run(
+    input.provider,
+    input.repo,
+    input.skill_id,
+    input.skill_label,
+    input.status,
+    input.command,
+    input.error,
+    input.run_started_at,
+    input.run_completed_at,
+    input.created_at,
+    input.updated_at
+  );
+}
+
+export function listSkillHistory(limit = 50, provider?: string): SkillHistoryRow[] {
+  const db = getSQLiteDb();
+  const params: Array<string | number> = [];
+  let where = "";
+  const normalizedProvider = provider ? normalizeSkillLearnProvider(provider) : null;
+  if (normalizedProvider) {
+    where = "WHERE provider = ?";
+    params.push(normalizedProvider);
+  }
+  params.push(limit);
+  return db
+    .prepare(
+      `SELECT id, provider, repo, skill_id, skill_label, status, command, error, run_started_at, run_completed_at, created_at, updated_at
+       FROM skill_learning_history
+       ${where}
+       ORDER BY updated_at DESC, created_at DESC
+       LIMIT ?`
+    )
+    .all(...params) as SkillHistoryRow[];
+}
+
+export function listAvailableSkills(provider?: string): Array<{
+  provider: ChatProvider | "unknown";
+  repo: string;
+  skill_id: string;
+  skill_label: string;
+  learned_at: number;
+}> {
+  const db = getSQLiteDb();
+  const params: Array<string | number> = [];
+  let where = "status = 'succeeded'";
+  const normalizedProvider = provider ? normalizeSkillLearnProvider(provider) : null;
+  if (normalizedProvider) {
+    where += " AND provider = ?";
+    params.push(normalizedProvider);
+  }
+  return db
+    .prepare(
+      `SELECT provider, repo, skill_id, skill_label, MAX(COALESCE(run_completed_at, updated_at, created_at)) AS learned_at
+       FROM skill_learning_history
+       WHERE ${where}
+       GROUP BY provider, repo, skill_id, skill_label
+       ORDER BY learned_at DESC`
+    )
+    .all(...params) as Array<{
+      provider: ChatProvider | "unknown";
+      repo: string;
+      skill_id: string;
+      skill_label: string;
+      learned_at: number;
+    }>;
+}
+
+export function installSkill(input: {
+  repo: string;
+  skillId: string;
+  providers: ChatProvider[];
+}): {
+  ok: boolean;
+  command: string;
+  stdout: string;
+  stderr: string;
+  results: Array<{ provider: ChatProvider; ok: boolean; agent: string }>;
+  error?: string;
+} {
+  const providers = Array.from(new Set(input.providers.map((provider) => normalizeSkillLearnProvider(provider)).filter(Boolean))) as ChatProvider[];
+  if (providers.length === 0) {
+    return { ok: false, command: "", stdout: "", stderr: "", results: [], error: "No supported providers selected" };
+  }
+
+  const startedAt = Date.now();
+  const results: Array<{ provider: ChatProvider; ok: boolean; agent: string }> = [];
+  let lastStdout = "";
+  let lastStderr = "";
+  let lastCommand = "";
+  const providersByAgent = new Map<string, ChatProvider[]>();
+
+  for (const provider of providers) {
+    const agent = skillAgentName(provider);
+    if (!agent) {
+      continue;
+    }
+    const group = providersByAgent.get(agent) ?? [];
+    group.push(provider);
+    providersByAgent.set(agent, group);
+  }
+
+  for (const [agent, agentProviders] of providersByAgent.entries()) {
+    const args = ["--yes", "skills@latest", "add", input.repo, "--skill", input.skillId, "--agent", agent, "--yes"];
+    lastCommand = `npx ${args.join(" ")}`;
+    const run = spawnSync("npx", args, {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      timeout: 120000,
+      env: { ...process.env, FORCE_COLOR: "0" },
+    });
+    lastStdout = String(run.stdout ?? "");
+    lastStderr = String(run.stderr ?? "");
+    const ok = run.status === 0;
+    for (const provider of agentProviders) {
+      results.push({ provider, ok, agent });
+      recordSkillHistory({
+        provider,
+        repo: input.repo,
+        skill_id: input.skillId,
+        skill_label: input.skillId,
+        status: ok ? "succeeded" : "failed",
+        command: lastCommand,
+        error: ok ? null : collapseWhitespace(lastStderr || lastStdout).slice(0, 1000),
+        run_started_at: startedAt,
+        run_completed_at: Date.now(),
+        created_at: startedAt,
+        updated_at: Date.now(),
+      });
+    }
+    if (!ok) {
+      return {
+        ok: false,
+        command: lastCommand,
+        stdout: lastStdout,
+        stderr: lastStderr,
+        results,
+        error: collapseWhitespace(lastStderr || lastStdout) || "Installation failed",
+      };
+    }
+  }
+
+  return { ok: true, command: lastCommand, stdout: lastStdout, stderr: lastStderr, results };
+}
+
+export function removeSkill(input: {
+  skillId: string;
+  providers: ChatProvider[];
+}): {
+  ok: boolean;
+  command: string;
+  stdout: string;
+  stderr: string;
+  results: Array<{ provider: ChatProvider; ok: boolean; agent: string }>;
+  error?: string;
+} {
+  const providers = Array.from(new Set(input.providers.map((provider) => normalizeSkillLearnProvider(provider)).filter(Boolean))) as ChatProvider[];
+  if (providers.length === 0) {
+    return { ok: false, command: "", stdout: "", stderr: "", results: [], error: "No supported providers selected" };
+  }
+
+  const startedAt = Date.now();
+  const results: Array<{ provider: ChatProvider; ok: boolean; agent: string }> = [];
+  let lastStdout = "";
+  let lastStderr = "";
+  let lastCommand = "";
+  const providersByAgent = new Map<string, ChatProvider[]>();
+
+  for (const provider of providers) {
+    const agent = skillAgentName(provider);
+    if (!agent) {
+      continue;
+    }
+    const group = providersByAgent.get(agent) ?? [];
+    group.push(provider);
+    providersByAgent.set(agent, group);
+  }
+
+  for (const [agent, agentProviders] of providersByAgent.entries()) {
+    const args = ["--yes", "skills@latest", "remove", input.skillId, "--agent", agent, "--yes"];
+    lastCommand = `npx ${args.join(" ")}`;
+    const run = spawnSync("npx", args, {
+      cwd: process.cwd(),
+      encoding: "utf8",
+      timeout: 120000,
+      env: { ...process.env, FORCE_COLOR: "0" },
+    });
+    lastStdout = String(run.stdout ?? "");
+    lastStderr = String(run.stderr ?? "");
+    const ok = run.status === 0;
+    for (const provider of agentProviders) {
+      results.push({ provider, ok, agent });
+      recordSkillHistory({
+        provider,
+        repo: "local/remove",
+        skill_id: input.skillId,
+        skill_label: input.skillId,
+        status: ok ? "succeeded" : "failed",
+        command: lastCommand,
+        error: ok ? null : collapseWhitespace(lastStderr || lastStdout).slice(0, 1000),
+        run_started_at: startedAt,
+        run_completed_at: Date.now(),
+        created_at: startedAt,
+        updated_at: Date.now(),
+      });
+    }
+    if (!ok) {
+      return {
+        ok: false,
+        command: lastCommand,
+        stdout: lastStdout,
+        stderr: lastStderr,
+        results,
+        error: collapseWhitespace(lastStderr || lastStdout) || "Removal failed",
+      };
+    }
+  }
+
+  return { ok: true, command: lastCommand, stdout: lastStdout, stderr: lastStderr, results };
+}

package/cloud-runtime/standalone/lib/sqlite-query-adapter.ts

@@ -144,6 +144,7 @@ function runMigrations(db: Database.Database): void {
     if (!agentColNames.has("model")) db.exec("ALTER TABLE agents ADD COLUMN model TEXT");
     if (!agentColNames.has("provider")) db.exec("ALTER TABLE agents ADD COLUMN provider TEXT");
     if (!agentColNames.has("color")) db.exec("ALTER TABLE agents ADD COLUMN color TEXT");
+    if (!agentColNames.has("title")) db.exec("ALTER TABLE agents ADD COLUMN title TEXT");
   }
 
   db.exec(`
@@ -157,6 +158,37 @@ function runMigrations(db: Database.Database): void {
     CREATE INDEX IF NOT EXISTS idx_agent_skills_agent ON agent_skills (agent_id);
   `);
 
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS skill_learning_history (
+      id TEXT NOT NULL PRIMARY KEY DEFAULT (lower(hex(randomblob(4)) || '-' || hex(randomblob(2)) || '-4' || substr(hex(randomblob(2)),2) || '-' || substr('89ab',abs(random()) % 4 + 1, 1) || substr(hex(randomblob(2)),2) || '-' || hex(randomblob(6)))),
+      provider TEXT NOT NULL,
+      repo TEXT NOT NULL,
+      skill_id TEXT NOT NULL,
+      skill_label TEXT NOT NULL,
+      status TEXT NOT NULL CHECK(status IN ('running', 'succeeded', 'failed')),
+      command TEXT NOT NULL,
+      error TEXT,
+      run_started_at INTEGER,
+      run_completed_at INTEGER,
+      created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+      updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+    );
+    CREATE INDEX IF NOT EXISTS idx_skill_learning_history_provider_status_updated ON skill_learning_history(provider, status, updated_at DESC);
+    CREATE INDEX IF NOT EXISTS idx_skill_learning_history_skill_lookup ON skill_learning_history(provider, repo, skill_id, updated_at DESC);
+  `);
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS agent_skill_bindings (
+      agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+      repo TEXT NOT NULL,
+      skill_id TEXT NOT NULL,
+      condition TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      PRIMARY KEY (agent_id, repo, skill_id)
+    );
+    CREATE INDEX IF NOT EXISTS idx_agent_skill_bindings_agent ON agent_skill_bindings (agent_id, created_at);
+  `);
+
   // Create project_agents table
   db.exec(`
     CREATE TABLE IF NOT EXISTS project_agents (

package/cloud-runtime/standalone/lib/stream-multiplexer.ts

@@ -20,6 +20,7 @@ import { appendReaction } from "./mesh-core/reactions";
 import { logActivity } from "./mesh-core/activity";
 import type { MeshReactionType } from "./mesh-core/types";
 import { listKnowledgeEntries, storeKnowledgeEntries, type KnowledgeEvidence } from "./knowledge-store";
+import { resolveBoundSkillFiles } from "./agent-skill-bindings";
 import { randomUUID, createHash } from "crypto";
 
 /** Per-agent message counter for reflection cadence */
@@ -33,12 +34,46 @@ function isKnowledgeEvidence(
   return value !== null;
 }
 
-function seedFromIdentityText(identity: string | undefined, name: string): string {
+const DEFAULT_RUNTIME_SEED = "I evolve through experience and collaboration.";
+
+function normalizeRuntimeSeedText(raw: string, name: string): string {
+  const collapsed = raw.replace(/\s+/g, " ").trim();
+  if (!collapsed) return `I am ${name}. ${DEFAULT_RUNTIME_SEED}`;
+
+  const withoutSecondPersonLead = collapsed.replace(
+    /^you are\b[^.!?\n]*[.!?]?\s*/i,
+    `I am ${name}. `,
+  );
+  const normalized = /^i am\b/i.test(withoutSecondPersonLead)
+    ? withoutSecondPersonLead
+    : `I am ${name}. ${withoutSecondPersonLead}`;
+
+  return normalized.slice(0, 500).trim();
+}
+
+export function seedFromIdentityText(
+  identity: string | undefined,
+  name: string,
+  explicitSeed?: string,
+): string {
+  const preferredSeed = String(explicitSeed || "").trim();
+  if (preferredSeed) {
+    return normalizeRuntimeSeedText(preferredSeed, name);
+  }
+
   const raw = String(identity || "").trim();
-  if (!raw) return `I am ${name}. I evolve through experience and collaboration.`;
-  // Identity text is a system prompt ("You are X..."). Don't use it verbatim as a seed.
-  // Extract a clean first-person description instead.
-  return `I am ${name}. I evolve through experience and collaboration.`;
+  if (!raw) return `I am ${name}. ${DEFAULT_RUNTIME_SEED}`;
+  return normalizeRuntimeSeedText(raw, name);
+}
+
+export function buildParticipantIdentity(p: Participant, identityOverride?: string): string | undefined {
+  const parts = [
+    String(identityOverride ?? p.identity ?? "").trim(),
+    p.voice?.trim() ? `Voice: ${p.voice.trim()}` : "",
+    p.seed?.trim() ? `Core orientation: ${p.seed.trim()}` : "",
+  ].filter(Boolean);
+
+  return parts.length > 0 ? parts.join("\n\n") : undefined;
 }
 
 function derivePerMessageJournalInsights(
@@ -112,8 +147,8 @@ function derivePerMessageJournalInsights(
 
 function ensureAgentArtifacts(p: Participant, identityText?: string): void {
   ensureAgent(p.id, {
-    voice: `${p.name} style`,
-    seed: seedFromIdentityText(identityText, p.name),
+    voice: p.voice?.trim() || `${p.name} style`,
+    seed: seedFromIdentityText(identityText, p.name, p.seed),
   });
 }
 
@@ -468,7 +503,8 @@ function cleanParallelMentions(text: string, all: Participant[]): string {
 
 function resolveRuntimeSkills(
   participant: Participant,
-  projectContext: StreamProjectContext | undefined
+  projectContext: StreamProjectContext | undefined,
+  prompt: string
 ): Array<{ file: string; condition?: string; source: "agent" | "project" }> {
   const fromProvenance = projectContext?.provenanceByAgentId?.[participant.id]?.skills;
   if (fromProvenance && fromProvenance.length > 0) {
@@ -485,6 +521,13 @@ function resolveRuntimeSkills(
     resolved.push({ file: skill.file, condition: skill.condition, source: "agent" });
   }
 
+  for (const skill of resolveBoundSkillFiles(participant.skillBindings ?? [], prompt, participant.provider)) {
+    const basename = skill.file.split("/").pop() || skill.file;
+    if (seen.has(basename)) continue;
+    seen.add(basename);
+    resolved.push({ file: skill.file, condition: skill.condition, source: "agent" });
+  }
+
   for (const skill of projectContext?.skills ?? []) {
     const basename = skill.file.split("/").pop() || skill.file;
     if (seen.has(basename)) continue;
@@ -708,11 +751,16 @@ async function runAgent(
       : text;
 
   // Resolve identity from the canonical DB-backed fields only.
-  let resolvedIdentity = p.identity ? interpolate(p.identity) : p.identity;
+  const interpolatedIdentity = p.identity ? interpolate(p.identity) : p.identity;
+  const interpolatedSeed = p.seed ? interpolate(p.seed) : p.seed;
+  let resolvedIdentity = buildParticipantIdentity(
+    { ...p, identity: interpolatedIdentity, seed: interpolatedSeed },
+    interpolatedIdentity,
+  );
 
   // Resolve self-model and knowledge as separate prompt inputs.
   let selfContent: string | undefined;
-  ensureAgentArtifacts(p, resolvedIdentity);
+  ensureAgentArtifacts({ ...p, seed: interpolatedSeed }, resolvedIdentity);
   const agentSelf = readSelf(p.id);
   if (agentSelf?.content) {
     selfContent = `[Self-Model]\n${agentSelf.content}`;
@@ -729,7 +777,7 @@ async function runAgent(
 
   // Resolve skills: read each file and concatenate with conditions
   let skillsContent: string | undefined;
-  const resolvedSkills = resolveRuntimeSkills(p, projectContext);
+  const resolvedSkills = resolveRuntimeSkills(p, projectContext, prompt);
   if (resolvedSkills.length > 0) {
     const parts = await Promise.all(
       resolvedSkills.map(async (skill) => {

package/cloud-runtime/standalone/lib/types.ts

@@ -12,12 +12,16 @@ export interface Conversation {
 export interface Participant {
   id: string;
   name: string;
+  title?: string;
   provider: ChatProvider;
   model: string | null;
   color: string;
   identity?: string;
+  voice?: string;
+  seed?: string;
   identityFile?: string;
   skills?: Skill[];
+  skillBindings?: SkillBinding[];
   variables?: Record<string, string>;
 }
 
@@ -26,6 +30,12 @@ export interface Skill {
   condition: string;
 }
 
+export interface SkillBinding {
+  repo: string;
+  skillId: string;
+  condition?: string;
+}
+
 export type ReactionType = "ack" | "working" | "done" | "clarify" | "blocked";
 
 export interface MessageReaction {

package/cloud-runtime/standalone/migrations/sqlite_schema.sql

@@ -311,6 +311,7 @@ CREATE TABLE IF NOT EXISTS agents (
     model TEXT,
     provider TEXT,
     color TEXT,
+    title TEXT,
     created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
     updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
     CHECK (style IN ('degen', 'conservative', 'specialist', 'balanced'))
@@ -324,6 +325,30 @@ CREATE TABLE IF NOT EXISTS agent_skills (
     PRIMARY KEY (agent_id, file)
 );
 
+CREATE TABLE IF NOT EXISTS skill_learning_history (
+    id TEXT NOT NULL PRIMARY KEY DEFAULT (lower(hex(randomblob(4)) || '-' || hex(randomblob(2)) || '-4' || substr(hex(randomblob(2)),2) || '-' || substr('89ab',abs(random()) % 4 + 1, 1) || substr(hex(randomblob(2)),2) || '-' || hex(randomblob(6)))),
+    provider TEXT NOT NULL,
+    repo TEXT NOT NULL,
+    skill_id TEXT NOT NULL,
+    skill_label TEXT NOT NULL,
+    status TEXT NOT NULL CHECK(status IN ('running', 'succeeded', 'failed')),
+    command TEXT NOT NULL,
+    error TEXT,
+    run_started_at INTEGER,
+    run_completed_at INTEGER,
+    created_at INTEGER NOT NULL DEFAULT (unixepoch()),
+    updated_at INTEGER NOT NULL DEFAULT (unixepoch())
+);
+
+CREATE TABLE IF NOT EXISTS agent_skill_bindings (
+    agent_id TEXT NOT NULL REFERENCES agents(id) ON DELETE CASCADE,
+    repo TEXT NOT NULL,
+    skill_id TEXT NOT NULL,
+    condition TEXT,
+    created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+    PRIMARY KEY (agent_id, repo, skill_id)
+);
+
 -- ── Execution graph tables (v2 DAG persistence) ────────────────────────────
 
 CREATE TABLE IF NOT EXISTS execution_graphs (
@@ -437,6 +462,9 @@ CREATE INDEX IF NOT EXISTS idx_workflows_user ON workflows (user_id);
 CREATE INDEX IF NOT EXISTS idx_agents_user ON agents (user_id);
 CREATE INDEX IF NOT EXISTS idx_agents_style ON agents (style);
 CREATE INDEX IF NOT EXISTS idx_agent_skills_agent ON agent_skills (agent_id);
+CREATE INDEX IF NOT EXISTS idx_agent_skill_bindings_agent ON agent_skill_bindings (agent_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_skill_learning_history_provider_status_updated ON skill_learning_history(provider, status, updated_at DESC);
+CREATE INDEX IF NOT EXISTS idx_skill_learning_history_skill_lookup ON skill_learning_history(provider, repo, skill_id, updated_at DESC);
 CREATE UNIQUE INDEX IF NOT EXISTS task_templates_public_slug_idx ON task_templates (slug) WHERE user_id IS NULL;
 CREATE UNIQUE INDEX IF NOT EXISTS task_templates_user_slug_idx ON task_templates (user_id, slug) WHERE user_id IS NOT NULL;
 CREATE UNIQUE INDEX IF NOT EXISTS idx_execution_graphs_task_id ON execution_graphs (task_id);