fix agent share card details

scripts/validate-bundled-agents.ts

@@ -19,10 +19,16 @@ import YAML from "yaml";
 
 const FRONTMATTER_RE = /^---\n([\s\S]*?)\n---(?:\n|$)/;
 const APP_AVATAR_REF_RE = /^app-avatar:[a-z0-9][a-z0-9_-]{0,63}$/;
+const CARD_COPY_MAX_GRAPHEMES = { good_for: 44, vibes: 32 } as const;
+const GRAPHEME_SEGMENTER = new Intl.Segmenter("en", {
+  granularity: "grapheme",
+});
 
 interface BundledAgentFrontmatter {
   name?: unknown;
   description?: unknown;
+  good_for?: unknown;
+  vibes?: unknown;
   avatar?: unknown;
   metadata?: { berdBundled?: unknown; [key: string]: unknown };
 }
@@ -94,6 +100,30 @@ export function validateBundledAgent(
     );
   }
 
+  for (const key of ["good_for", "vibes"] as const) {
+    if (
+      typeof frontmatter[key] !== "string" ||
+      frontmatter[key].trim() === ""
+    ) {
+      errors.push(
+        error(
+          `frontmatter \`${key}\` is required and must be a non-empty string`,
+          filePath,
+        ),
+      );
+    } else if (
+      Array.from(GRAPHEME_SEGMENTER.segment(frontmatter[key].trim())).length >
+      CARD_COPY_MAX_GRAPHEMES[key]
+    ) {
+      errors.push(
+        error(
+          `frontmatter \`${key}\` must be ${CARD_COPY_MAX_GRAPHEMES[key]} characters or fewer so card copy is never truncated`,
+          filePath,
+        ),
+      );
+    }
+  }
+
   if (
     typeof frontmatter.avatar !== "string" ||
     !APP_AVATAR_REF_RE.test(frontmatter.avatar)

src-tauri/src/services/bundled_agents.rs

@@ -5,6 +5,7 @@ use std::path::{Path, PathBuf};
 use std::sync::atomic::{AtomicU64, Ordering};
 
 use serde::{Deserialize, Serialize};
+use sha2::{Digest, Sha256};
 
 use crate::services::distro_bundle::DistroBundle;
 
@@ -14,6 +15,9 @@ const AGENTS_DIR_NAME: &str = "agents";
 const MARKER_FILE_NAME: &str = ".berd-bundled-agents.json";
 const LEGACY_MARKER_FILE_NAME: &str = ".goose-internal-bundled-agents.json";
 static INSTALL_TEMP_SEQUENCE: AtomicU64 = AtomicU64::new(0);
+const LEGACY_AGT_BUILDER_FILE_NAME: &str = "agt-builder.md";
+const LEGACY_AGT_BUILDER_FILE_SHA256: &str =
+    "15ac706dd4b14dced6368572f4f2f0b3e42d0263cafb5ec199e71cd034b14a9d";
 
 #[derive(Debug, Default, PartialEq, Eq)]
 pub struct SeedBundledAgentsResult {
@@ -245,6 +249,25 @@ fn seed_bundled_agents_from_dir(
     })
 }
 
+fn has_known_legacy_agt_builder_contents(path: &Path) -> Result<bool, String> {
+    let metadata = fs::symlink_metadata(path)
+        .map_err(|err| format!("Failed to inspect legacy agent '{}': {err}", path.display()))?;
+    if !metadata.file_type().is_file() || metadata.file_type().is_symlink() {
+        return Ok(false);
+    }
+    let contents = fs::read(path)
+        .map_err(|err| format!("Failed to read legacy agent '{}': {err}", path.display()))?;
+    let digest = format!("{:x}", Sha256::digest(contents));
+    Ok(digest == LEGACY_AGT_BUILDER_FILE_SHA256)
+}
+
+fn is_known_legacy_agt_builder(path: &Path) -> Result<bool, String> {
+    if path.file_name().and_then(|name| name.to_str()) != Some(LEGACY_AGT_BUILDER_FILE_NAME) {
+        return Ok(false);
+    }
+    has_known_legacy_agt_builder_contents(path)
+}
+
 fn should_install_agent(
     source: &Path,
     target: &Path,
@@ -253,6 +276,9 @@ fn should_install_agent(
     if !target.exists() {
         return Ok(!was_previously_seeded);
     }
+    if is_known_legacy_agt_builder(target)? {
+        return Ok(true);
+    }
     if !was_previously_seeded {
         return Ok(false);
     }
@@ -333,7 +359,8 @@ fn install_agent_file(source: &Path, target: &Path) -> Result<(), String> {
     if !matches!(
         installed_agent_path_state(target)?,
         InstalledAgentPathState::Missing | InstalledAgentPathState::Bundled
-    ) {
+    ) && !is_known_legacy_agt_builder(target)?
+    {
         return Err(format!(
             "Cannot install bundled agent over user-owned file '{}'",
             target.display()
@@ -372,6 +399,7 @@ fn install_agent_file(source: &Path, target: &Path) -> Result<(), String> {
         })?;
         match installed_agent_path_state(target)? {
             InstalledAgentPathState::Missing | InstalledAgentPathState::Bundled => {}
+            InstalledAgentPathState::UserOwned if is_known_legacy_agt_builder(target)? => {}
             InstalledAgentPathState::UserOwned => {
                 return Err(format!(
                     "Cannot install bundled agent over user-owned file '{}'",
@@ -385,7 +413,8 @@ fn install_agent_file(source: &Path, target: &Path) -> Result<(), String> {
                 source.display(),
                 target.display()
             )
-        })
+        })?;
+        Ok(())
     })();
     if install_result.is_err() {
         let _ = fs::remove_file(&temp_path);
@@ -588,6 +617,74 @@ mod tests {
         assert!(!target.path().join(LEGACY_MARKER_FILE_NAME).exists());
     }
 
+    #[test]
+    fn production_signature_recognizes_the_historical_agt_builder() {
+        let target = tempdir().unwrap();
+        let path = target.path().join(LEGACY_AGT_BUILDER_FILE_NAME);
+        fs::write(
+            &path,
+            include_str!("../../test-fixtures/legacy-agt-builder.md"),
+        )
+        .unwrap();
+
+        assert!(is_known_legacy_agt_builder(&path).unwrap());
+    }
+
+    #[test]
+    fn replaces_exact_legacy_agt_builder_directly() {
+        let source = tempdir().unwrap();
+        let target = tempdir().unwrap();
+        let bundled = "---\nname: Agt. Builder\ndescription: Current\nmetadata:\n  berdBundled: true\n---\nCurrent instructions.";
+        fs::write(source.path().join(LEGACY_AGT_BUILDER_FILE_NAME), bundled).unwrap();
+        fs::write(
+            target.path().join(LEGACY_AGT_BUILDER_FILE_NAME),
+            include_str!("../../test-fixtures/legacy-agt-builder.md"),
+        )
+        .unwrap();
+
+        let result = seed_bundled_agents_from_dir(source.path(), target.path()).unwrap();
+
+        assert_eq!(result.seeded_count, 1);
+        assert_eq!(
+            fs::read_to_string(target.path().join(LEGACY_AGT_BUILDER_FILE_NAME)).unwrap(),
+            bundled
+        );
+    }
+
+    #[test]
+    fn preserves_a_legacy_agt_builder_with_a_custom_avatar() {
+        let target = tempdir().unwrap();
+        let path = target.path().join(LEGACY_AGT_BUILDER_FILE_NAME);
+        let fixture = include_str!("../../test-fixtures/legacy-agt-builder.md");
+        fs::write(
+            &path,
+            fixture.replacen("data:image/png;base64,", "data:image/png;base64,CUSTOM", 1),
+        )
+        .unwrap();
+
+        assert!(!is_known_legacy_agt_builder(&path).unwrap());
+    }
+
+    #[test]
+    fn preserves_a_legacy_agt_builder_with_different_line_endings() {
+        let target = tempdir().unwrap();
+        let path = target.path().join(LEGACY_AGT_BUILDER_FILE_NAME);
+        let fixture = include_str!("../../test-fixtures/legacy-agt-builder.md");
+        fs::write(&path, fixture.replace('\n', "\r\n")).unwrap();
+
+        assert!(!is_known_legacy_agt_builder(&path).unwrap());
+    }
+
+    #[test]
+    fn preserves_a_modified_legacy_agt_builder() {
+        let target = tempdir().unwrap();
+        let path = target.path().join(LEGACY_AGT_BUILDER_FILE_NAME);
+        let fixture = include_str!("../../test-fixtures/legacy-agt-builder.md");
+        fs::write(&path, fixture.replacen("name:", "# user note\nname:", 1)).unwrap();
+
+        assert!(!is_known_legacy_agt_builder(&path).unwrap());
+    }
+
     #[test]
     fn treats_existing_user_agent_as_already_handled() {
         let source = tempdir().unwrap();

src/features/agents/agent-snapshot/mapping.test.ts

@@ -123,6 +123,8 @@ describe("snapshot mappings", () => {
       profile: {
         displayName: "Builder",
         about: null,
+        goodFor: null,
+        vibes: null,
         avatarDataUrl: null,
         avatarUrl: null,
       },
@@ -132,6 +134,87 @@ describe("snapshot mappings", () => {
     );
   });
 
+  it.each([
+    "Agent",
+    "Draft",
+    "  agent  ",
+  ])("does not export placeholder description %j", (sourceDescription) => {
+    expect(
+      personaToSnapshot(persona({ sourceDescription })).profile?.about,
+    ).toBeNull();
+  });
+
+  it("round-trips the reviewed public description", () => {
+    const exported = personaToSnapshot(
+      persona({ sourceDescription: "Builds useful things." }),
+    );
+    expect(snapshotToCreatePersonaRequest(exported).description).toBe(
+      "Builds useful things.",
+    );
+  });
+
+  it("bounds public descriptions by grapheme without failing export", () => {
+    const description = "😀".repeat(120);
+    const exported = personaToSnapshot(
+      persona({ sourceDescription: description }),
+    );
+    expect(exported.profile?.about).toBe("😀".repeat(110));
+    expect(snapshotToCreatePersonaRequest(exported).description).toBe(
+      "😀".repeat(110),
+    );
+  });
+
+  it("accepts long v1 descriptions and bounds the imported presentation copy", () => {
+    const value = snapshot({
+      profile: {
+        displayName: "Display name",
+        about: "a".repeat(200),
+      },
+    });
+    expect(snapshotToCreatePersonaRequest(value).description).toBe(
+      "a".repeat(110),
+    );
+  });
+
+  it("round-trips grapheme-bounded Unicode share-card metadata", () => {
+    const goodFor = "👨‍👩‍👧‍👦".repeat(44);
+    const vibes = "😀".repeat(32);
+    const exported = personaToSnapshot(persona({ goodFor, vibes }));
+    expect(snapshotToCreatePersonaRequest(exported)).toMatchObject({
+      goodFor,
+      vibes,
+    });
+  });
+
+  it.each([
+    [{ legacy: true }, ["calm"]],
+    ["x".repeat(4_097), "y".repeat(4_097)],
+    ["😀".repeat(45), "😀".repeat(33)],
+  ])("ignores incompatible v1 card metadata without rejecting the snapshot", (goodFor, vibes) => {
+    const value = snapshot({
+      profile: {
+        displayName: "Display name",
+        goodFor: goodFor as string,
+        vibes: vibes as string,
+      },
+    });
+
+    expect(snapshotToCreatePersonaRequest(value)).not.toMatchObject({
+      goodFor: expect.anything(),
+      vibes: expect.anything(),
+    });
+  });
+
+  it("round-trips short share-card metadata", () => {
+    const exported = personaToSnapshot(
+      persona({ goodFor: "building useful tools", vibes: "sharp, practical" }),
+    );
+    expect(snapshotToCreatePersonaRequest(exported)).toMatchObject({
+      goodFor: "building useful tools",
+      vibes: "sharp, practical",
+    });
+  });
+
   it("exports safe URL and data URL avatars only", () => {
     expect(
       personaToSnapshot(persona({ avatar: "https://example.com/a.png" }))

src/features/agents/agent-snapshot/mapping.ts

@@ -1,4 +1,7 @@
 import type { CreatePersonaRequest, Persona } from "@/shared/types/agents";
+import { getRealPersonaDescription } from "@/features/agents/lib/personaPresentation";
+import { truncateCardGraphemes } from "@/features/agents/ui/share-card/agentShareCardText";
+import { graphemeCount } from "@/shared/lib/graphemeCount";
 import {
   isRemoteAvatarUrl,
   isSafePngAvatarDataUrl,
@@ -10,6 +13,21 @@ import {
   validateSnapshotV1,
 } from "./schema";
 
+const MAX_CARD_COPY_RAW_LENGTH = 4_096;
+
+function validOptionalCardCopy(
+  value: unknown,
+  maxGraphemes: number,
+): string | undefined {
+  if (typeof value !== "string" || value.length > MAX_CARD_COPY_RAW_LENGTH) {
+    return undefined;
+  }
+  const trimmed = value.trim();
+  return trimmed && graphemeCount(trimmed) <= maxGraphemes
+    ? trimmed
+    : undefined;
+}
+
 export interface SnapshotMappingSupport {
   /** Return true only when this exact provider/model can be selected locally. */
   supportsConfiguration?: (provider: string, model: string) => boolean;
@@ -41,6 +59,14 @@ export function snapshotToCreatePersonaRequest(
       snapshot.definition.modelProviderId?.trim() || undefined;
     request.model = model;
   }
+  const about = snapshot.profile?.about;
+  if (typeof about === "string" && about.trim()) {
+    request.description = truncateCardGraphemes(about.trim(), 110);
+  }
+  const goodFor = validOptionalCardCopy(snapshot.profile?.goodFor, 44);
+  const vibes = validOptionalCardCopy(snapshot.profile?.vibes, 32);
+  if (goodFor) request.goodFor = goodFor;
+  if (vibes) request.vibes = vibes;
   const avatarDataUrl = snapshot.profile?.avatarDataUrl;
   if (
     typeof avatarDataUrl === "string" &&
@@ -56,6 +82,7 @@ export function snapshotToCreatePersonaRequest(
 /** Creates a deterministic, config-only snapshot without persistent or secret persona metadata. */
 export function personaToSnapshot(persona: Persona): SnapshotV1 {
   const displayName = persona.displayName.trim();
+  const authoredDescription = getRealPersonaDescription(persona);
   const snapshot: SnapshotV1 = {
     format: SNAPSHOT_FORMAT,
     version: SNAPSHOT_VERSION,
@@ -75,7 +102,11 @@ export function personaToSnapshot(persona: Persona): SnapshotV1 {
     },
     profile: {
       displayName,
-      about: null,
+      about: authoredDescription
+        ? truncateCardGraphemes(authoredDescription, 110)
+        : null,
+      goodFor: persona.goodFor ?? null,
+      vibes: persona.vibes ?? null,
       avatarDataUrl:
         typeof persona.avatar === "string" &&
         isSafePngAvatarDataUrl(persona.avatar)

src/features/agents/agent-snapshot/schema.ts

@@ -15,6 +15,7 @@ export const MAX_SNAPSHOT_AVATAR_DATA_URL_LENGTH =
   Math.ceil((2 * 1024 * 1024) / 3) * 4 + "data:image/png;base64,".length;
 export const MAX_SNAPSHOT_AVATAR_URL_LENGTH = 2_048;
 export const MAX_SNAPSHOT_PROVIDER_MODEL_LENGTH = 512;
+const MAX_SNAPSHOT_CARD_COPY_RAW_LENGTH = 4_096;
 
 export interface SnapshotV1Definition {
   name?: string;
@@ -35,6 +36,8 @@ export interface SnapshotV1Definition {
 export interface SnapshotV1Profile {
   displayName?: string;
   about?: string | null;
+  goodFor?: string | null;
+  vibes?: string | null;
   avatarDataUrl?: string | null;
   avatarUrl?: string | null;
   [field: string]: unknown;
@@ -152,6 +155,7 @@ export function validateSnapshotV1(value: unknown): SnapshotV1 {
   const profile = isRecord(value.profile) ? value.profile : undefined;
   if (profile) {
     optionalString(profile, "displayName", MAX_SNAPSHOT_NAME_LENGTH);
+    optionalString(profile, "about", MAX_SNAPSHOT_CARD_COPY_RAW_LENGTH);
     optionalString(
       profile,
       "avatarDataUrl",