@vibes.diy/api-svc 14.3.90 → 14.3.92

package/intern/mercury-first-build.js

@@ -4,7 +4,8 @@ import { type } from "arktype";
 import { lazyType } from "@vibes.diy/api-types/lazy-type";
 import { sanitizeRoomShortlist } from "@vibes.diy/prompts";
 import { keepsToThemselves as keepsToThemselvesWords } from "./keeps-to-themselves.js";
-import { KNOWN_VALUES_DIRECT_CONTROLS } from "./agent-session-instruction.js";
+import { KNOWN_VALUES_DIRECT_CONTROLS, PHONE_GAME_CONTROLS_LINE } from "./agent-session-instruction.js";
+import { AGENT_SKILLS_PROSE, agentNameableSkills, agentSkillMenu } from "./agent-skill-catalog.js";
 import { poufRoomCatalog, poufRoomSlugs } from "./pouf-room-catalog.js";
 import { vibeFontCatalog, vibeFontSlugs } from "./vibe-font-catalog.js";
 import { slugWordBag } from "./ensure-slug-binding.js";
@@ -33,49 +34,45 @@ class MercuryTransientError extends Error {
         this.retryAfterMs = retryAfterMs;
     }
 }
-export const MERCURY_ARCHETYPES = ["personal", "group", "publish", "intake", "open", "toy"];
-export const MERCURY_FLAGS = [
-    "ai",
-    "composer",
-    "imageGen",
-    "backend",
-    "calendar",
-    "audio",
-    "threeD",
-    "charts",
-    "boardGame",
-    "sensitive",
-];
+export const MERCURY_APP_SHAPES = ["personal", "playful", "group", "publish", "intake", "open"];
+export function readMercuryAppShape(word) {
+    const w = word.toLowerCase().match(/[a-z]+/)?.[0] ?? "";
+    if (w === "toy")
+        return "playful";
+    return MERCURY_APP_SHAPES.find((a) => a === w);
+}
+export const MERCURY_FLAGS = ["composer", "sensitive"];
 const COMPOSER_WORDS = /paste|photo|picture|own words|however they|repl(y|ies)|in their words|type in|jot/;
 const PRIVATE_WORDS = /\b(private|just for me|only me|for myself)\b/;
 const MULTIPLAYER_WORDS = /\b(friends? can join|multi-?players?|same world)\b/;
 export function fixMercuryShape(shape, personWords) {
     const m = personWords.toLowerCase();
-    const composer = shape.flags.ai && shape.flags.composer && COMPOSER_WORDS.test(m);
+    const composer = shape.flags.composer && COMPOSER_WORDS.test(m);
     const privateAsk = PRIVATE_WORDS.test(m);
     const keepsToThemselves = keepsToThemselvesWords(personWords);
-    const keepsPersonal = keepsToThemselves && shape.archetype !== "toy" && shape.archetype !== "personal";
-    const archetype = keepsPersonal || (privateAsk && (shape.archetype === "open" || shape.archetype === "publish"))
+    const keepsPersonal = keepsToThemselves && shape.appShape !== "playful" && shape.appShape !== "personal";
+    const appShape = keepsPersonal || (privateAsk && (shape.appShape === "open" || shape.appShape === "publish"))
         ? "personal"
-        : shape.archetype === "toy" && MULTIPLAYER_WORDS.test(m)
+        : shape.appShape === "playful" && MULTIPLAYER_WORDS.test(m)
             ? "open"
-            : shape.archetype;
+            : shape.appShape;
     return {
         ...shape,
-        archetype,
+        appShape,
         recordNames: shape.recordNames
             .map((r) => r.trim())
             .filter((r) => r.length > 0)
             .slice(0, 5),
-        flags: { ...shape.flags, composer, threeD: shape.flags.threeD || mercuryBlockWorldNamed(personWords) },
+        flags: { ...shape.flags, composer },
         ...(keepsToThemselves ? { keepsToThemselves: true } : {}),
     };
 }
 const briefShapeParsed = lazyType(() => type({
-    archetype: type.enumerated(...MERCURY_ARCHETYPES),
+    appShape: type.enumerated(...MERCURY_APP_SHAPES),
     coreAction: "string",
     recordNames: "string[]",
     capabilities: type.enumerated(...MERCURY_FLAGS).array(),
+    "skills?": "string[]",
 }));
 export function parseMercuryBriefShape(raw, personWords) {
     const p = briefShapeParsed(raw);
@@ -85,7 +82,7 @@ export function parseMercuryBriefShape(raw, personWords) {
         return Result.Err("mercury classification: empty coreAction");
     const caps = new Set(p.capabilities);
     const flags = Object.fromEntries(MERCURY_FLAGS.map((f) => [f, caps.has(f)]));
-    return Result.Ok(fixMercuryShape({ archetype: p.archetype, coreAction: p.coreAction.trim(), recordNames: p.recordNames, flags }, personWords));
+    return Result.Ok(fixMercuryShape({ appShape: p.appShape, coreAction: p.coreAction.trim(), recordNames: p.recordNames, flags, skills: p.skills ?? [] }, personWords));
 }
 function setFlags(flags) {
     return MERCURY_FLAGS.filter((f) => flags[f]);
@@ -142,36 +139,28 @@ export function mercurySlugWordsSentence(words) {
 }
 export const MERCURY_ROOMS_HINT = "an array of 2 or 3 room slugs from the room list";
 export const MERCURY_FONT_HINT = "one font slug from the font list";
-const MERCURY_FIRST_PERSON_TRIGGER = "  - a first-person walk around a place";
-export const MERCURY_BLOCK_WORLD_TRIGGER = "  - a Minecraft-style block world to build and break blocks in";
-const MERCURY_BLOCK_WORLD_WORDS = /\b(minecraft|voxels?|block[- ]world|blocky|sandbox game)\b|\b(?:build|place|break|mine|dig)(?:s|ing)?(?:\s+(?:and|or|&)\s+(?:build|place|break|mine|dig)(?:s|ing)?)?\s+(?:the\s+|some\s+)?blocks\b/i;
-export function mercuryBlockWorldNamed(personWords) {
-    return MERCURY_BLOCK_WORLD_WORDS.test(personWords);
-}
-const MERCURY_REAL_TIME_GAME_WORDS = /\b(arcade|runner|racer|racing game|shooter|shoot[- ]?'?em[- ]?up|platformer|snake game|asteroids|pinball|slingshot|catapult|flappy|endless run|dodge|joystick|swipe to)\b/i;
-export function mercuryRealTimeGameNamed(personWords) {
-    return MERCURY_REAL_TIME_GAME_WORDS.test(personWords);
-}
-const MERCURY_LEAN_ARCHETYPES = `- personal: one person's own tool ("for me", "my", "private", a tracker, a log, a list, a journal) with no other people named.
+const MERCURY_LEAN_APP_SHAPES = `Decide playful first: would people happily show off what gets made here?
+- playful: a game, music or sound toy, drawing or pixel art, image or meme generator, quiz, bingo, or anything made for fun. What people make is shared with everyone who opens the app, even when the person says "my": "save my beats", "my drawings" and "my favorites" are playful.
+Otherwise, the one that fits who takes part:
+- personal: things private by nature, kept by one person about themselves: a journal, mood, health, money, habits, notes to self.
 - group: the person names other people who use it with them (we, our, friends, family, team, club, kids, housemates, partner, members, a foursome).
 - publish: the person writes and other people only read (a blog, menu, gallery, portfolio, schedule, zine, "everyone can read").
 - intake: strangers or customers submit something without signing up and the person sees the submissions (orders, bookings, requests, sign-ups, replies, reports from the public).
-- open: anyone with the link joins in and adds their own bit (a shared wall, canvas, feed, leaderboard game, community board, swap board, "anyone can post").
-- toy: a game, simulator, visual, sound or generator that keeps little or nothing (scores at most).`;
-const MERCURY_LEAN_CAPABILITIES = MERCURY_CAPABILITY_TRIGGERS.replace(/^A trigger is an example, not a password: [^\n]*?composer is set only together with ai\./, "composer goes with ai.");
+- open: anyone with the link joins in and adds their own bit (a shared wall, canvas, feed, leaderboard game, community board, swap board, "anyone can post").`;
+const MERCURY_LEAN_CAPABILITIES = MERCURY_CAPABILITY_TRIGGERS.replace(/^A trigger is an example, not a password: [^\n]*?composer is set only together with ai\./, "composer goes with callai.");
 function kebab(s) {
     return s
         .toLowerCase()
         .replace(/[^a-z0-9]+/g, "-")
         .replace(/^-+|-+$/g, "");
 }
-const LEADING_TAG = /^\s*\[(?:personal|group|publish|intake|open|toy)\]\s*/i;
-export function stripMercuryArchetypeTag(text) {
+const LEADING_TAG = /^\s*\[(?:personal|playful|group|publish|intake|open|toy)\]\s*/i;
+export function stripMercuryShapeTag(text) {
     return LEADING_TAG.test(text) ? { text: text.replace(LEADING_TAG, ""), repaired: true } : { text, repaired: false };
 }
 export function gateMercuryAddress(o) {
     const raw = o.title.trim();
-    const cut = stripMercuryArchetypeTag(raw);
+    const cut = stripMercuryShapeTag(raw);
     const title = cut.text.trim().replace(/^["*]+|["*]+$/g, "");
     const own = kebab(title);
     if (title.length === 0 || own.length === 0)
@@ -194,30 +183,41 @@ export function mercurySlugsWithWord(pairs, words) {
     const ws = words.map((w) => kebab(w)).filter((w) => w.length > 0);
     return pairs.filter((p) => ws.some((w) => p.slug.includes(w))).length;
 }
-const FLAG_SKILLS = [
-    ["ai", "callai"],
-    ["imageGen", "image-gen"],
-    ["backend", "backend"],
-    ["calendar", "calendar"],
-    ["audio", "web-audio"],
-    ["threeD", "three-js"],
-    ["charts", "d3"],
-    ["boardGame", "board-games"],
-];
-export function mercurySkills(shape, opts = {}) {
-    const words = opts.personWords ?? "";
-    const base = ["access", "fireproof", ...FLAG_SKILLS.filter(([f]) => shape.flags[f]).map(([, skill]) => skill)];
-    const skills = mercuryBlockWorldNamed(words) ? [...base.filter((k) => k !== "three-js"), "voxel", "three-js"] : base;
-    const realTime = mercuryBlockWorldNamed(words) || mercuryRealTimeGameNamed(words) || (shape.archetype === "toy" && shape.flags.threeD);
-    return realTime ? [...skills, "touch-games"] : skills;
+export function mercurySkills(shape) {
+    const out = [];
+    for (const k of ["access", "fireproof", ...shape.skills, ...(shape.flags.composer ? ["callai"] : [])])
+        if (!out.includes(k))
+            out.push(k);
+    return out;
+}
+export function gateMercurySkills(raw, opts) {
+    const nameable = agentNameableSkills(opts);
+    const skills = [];
+    const unknown = [];
+    for (const t of tailList(raw)) {
+        const name = t
+            .replace(/^[-*\u2022\s]+/, "")
+            .replace(/^["'`]+|["'`]+$/g, "")
+            .trim()
+            .toLowerCase();
+        if (name.length === 0 || /^(none|n\/a|nothing|-)$/.test(name))
+            continue;
+        if (!nameable.has(name)) {
+            if (!unknown.includes(name))
+                unknown.push(name);
+        }
+        else if (!skills.includes(name))
+            skills.push(name);
+    }
+    return { skills, unknown };
 }
 export function mercuryNature(shape, personWords) {
     if (shape.keepsToThemselves === true)
         return "sensitive";
     if (PRIVATE_WORDS.test(personWords.toLowerCase()))
         return "sensitive";
-    const a = shape.archetype;
-    if (a === "open" || a === "toy" || a === "publish")
+    const a = shape.appShape;
+    if (a === "open" || a === "playful" || a === "publish")
         return "open";
     return shape.flags.sensitive && (a === "personal" || a === "intake") ? "sensitive" : "collaborative";
 }
@@ -623,7 +623,7 @@ function tailList(v) {
         .trim())
         .filter((x) => x.length > 0 && /^(none|n\/a|nothing|-)$/i.test(x) === false);
 }
-export const MERCURY_CARDS_DEFAULT_ARCHETYPE = MERCURY_ARCHETYPES[0];
+export const MERCURY_CARDS_DEFAULT_APP_SHAPE = MERCURY_APP_SHAPES[0];
 export const MERCURY_TESTER_REPLY_INTRO = "A fast tester's first read:";
 export const MERCURY_TESTER_REPLY_RULE = "Guesses only; the creator's words win.";
 export const MERCURY_SHARING_LINE = {
@@ -632,7 +632,7 @@ export const MERCURY_SHARING_LINE = {
     publish: "The owner writes; everything they publish is readable by anyone with the link, signed in or not. Shaped so a co-owner could be let in later.",
     intake: "Every visitor adds submissions to the shared list, signed in or not; a signed-in visitor edits only their own (a signed-out submission is create-only — the rules have no identity to check it against), and the signed-in owner reads and manages all of them. Shaped so staff could be let in later.",
     open: "Everyone with the link reads the shared records — posts, votes, entries — signed in or not; every signed-in visitor adds their own and edits only their own, and the owner can remove anything.",
-    toy: "Anything players save — beats, levels, scores, creations — lands on one always-on public channel, readable by anyone with the link, signed in or not; each signed-in player edits only their own, and the owner can remove anything.",
+    playful: "Anything players save — beats, levels, scores, creations — lands on one always-on public channel, readable by anyone with the link, signed in or not; each signed-in player edits only their own, and the owner can remove anything.",
 };
 export const MERCURY_SHARING_KEEPS_TO_THEMSELVES = "Each person's records are theirs alone, and a one-tap publish shares a chosen one with everyone who can open the app.";
 export const MERCURY_SHARING_SENSITIVE = 'Each person\'s records are private to them from the first one, and sharing is theirs to turn on: a "Shared with followers" checkbox that starts unchecked, an add-buddies picker that grants one chosen handle, and a one-tap publish for a single finished item — never an always-on public channel for the records.';
@@ -642,30 +642,47 @@ export function mercurySharingLine(shape, personWords) {
         ? MERCURY_SHARING_KEEPS_TO_THEMSELVES
         : mercuryNature(shape, personWords) === "sensitive"
             ? MERCURY_SHARING_SENSITIVE
-            : MERCURY_SHARING_LINE[shape.archetype];
+            : MERCURY_SHARING_LINE[shape.appShape];
     return `${MERCURY_SHARING_PREFIX} ${line}`;
 }
-export function mercuryTesterReplyEnrichedPrompt(reply, personWords, shape) {
+export function mercuryReplyForBuilder(reply) {
+    const lines = reply.split("\n");
+    const at = lines.findIndex((l) => APP_MARKER_LINE.test(l));
+    if (at < 0)
+        return reply;
+    return [...lines.slice(0, at + 1), ...lines.slice(at + 1).filter((l) => !isShapeTailLine(l))].join("\n");
+}
+function isShapeTailLine(line) {
+    const k = TAIL_KEY_LINE.exec(line);
+    return k !== null && SHAPE_TAIL_KEYS.has(k[1].toLowerCase());
+}
+const SHAPE_TAIL_KEYS = new Set(["shape", "archetype"]);
+export function mercuryTesterReplyEnrichedPrompt(reply, personWords, shape, skills = mercurySkills(shape)) {
     return [
         MERCURY_TESTER_REPLY_INTRO,
-        `<tester-reply>\n${reply}\n</tester-reply>`,
+        `<tester-reply>\n${mercuryReplyForBuilder(reply)}\n</tester-reply>`,
         MERCURY_TESTER_REPLY_RULE,
         mercurySharingLine(shape, personWords),
-        ...mercuryCardsBuilderLines(shape),
+        ...mercuryCardsBuilderLines(shape, skills),
         `The app creator's initial prompt: "${personWords}"`,
     ].join("\n\n");
 }
 export const MERCURY_COMPOSER_LINE = "The records come in through a sentence composer (Add and Ask) as the front door.";
-export function mercuryCardsBuilderLines(shape) {
-    return [shape.flags.composer ? MERCURY_COMPOSER_LINE : "", KNOWN_VALUES_DIRECT_CONTROLS].filter((l) => l.length > 0);
+export function mercuryCardsBuilderLines(shape, skills = []) {
+    return [
+        shape.flags.composer ? MERCURY_COMPOSER_LINE : "",
+        KNOWN_VALUES_DIRECT_CONTROLS,
+        skills.includes("touch-games") ? PHONE_GAME_CONTROLS_LINE : "",
+    ].filter((l) => l.length > 0);
 }
 export const MERCURY_CARDS_MARKER = "--- CARDS ---";
 export const MERCURY_CARDS_APP_MARKER = "--- APP ---";
 export const MERCURY_CARDS_TAIL_HINTS = {
     title: "the app's name, two or three words in its own vocabulary",
     slugs: "three short kebab-case addresses for the app, comma-separated",
-    archetype: "one of personal, group, publish, intake, open, toy: the ownership shape that fits the person's words",
+    shape: "one of playful, personal, group, publish, intake, open: playful first when people would happily show off what gets made",
     capabilities: "the capabilities this request needs, from the capability list, comma-separated; none when it needs none",
+    skills: "the skills this build loads, by name from the skill list, comma-separated; none when it needs none",
 };
 export const MERCURY_CARDS_PREAMBLE_RULE = `Start with a short paragraph to the app creator, in plain warm words: what you're making for them and its most important workflow, walked through the way they'll do it. Say "probably" where you're guessing.`;
 export const MERCURY_CARDS_SHAPE = `As a <role>, I <action on a named record>, so that <outcome>.
@@ -681,7 +698,9 @@ export const MERCURY_CARDS_RULES = `Rules:
 - A line that rests on your assumption and not on the person's words ends with (guess). A line the person's words settle carries no label.
 - ${MERCURY_ASK_WORDS_RULE}
 - ${MERCURY_TYPED_DATA_RULE}`;
-const MERCURY_CARDS_CAPABILITIES = MERCURY_LEAN_CAPABILITIES.replace(MERCURY_FIRST_PERSON_TRIGGER, `${MERCURY_FIRST_PERSON_TRIGGER}\n${MERCURY_BLOCK_WORLD_TRIGGER}`);
+export function mercuryCardsSkillList(o) {
+    return `${AGENT_SKILLS_PROSE}${agentSkillMenu({ poufBlocks: o.poufBlocks })}`;
+}
 export function mercuryCardsSystem(o = {}) {
     const keys = {
         ...MERCURY_CARDS_TAIL_HINTS,
@@ -702,11 +721,14 @@ ${MERCURY_CARDS_RULES}
 Then a line reading exactly "${MERCURY_CARDS_APP_MARKER}", then one line per key, as "key: value":
 ${tailLines}
 
-archetype, exactly one:
-${MERCURY_LEAN_ARCHETYPES}
+shape, exactly one:
+${MERCURY_LEAN_APP_SHAPES}
 
 capabilities: each capability the request itself needs, from this list; none when it needs none:
-${MERCURY_CARDS_CAPABILITIES}
+${MERCURY_LEAN_CAPABILITIES}
+
+skills: each skill this build loads, by name from this list; none when it needs none:
+${mercuryCardsSkillList({ poufBlocks: o.poufBlocks === true })}
 
 ${MERCURY_ADDRESS.rule}`;
 }
@@ -720,11 +742,11 @@ export function mercuryCardsMessages(o) {
         ...(o.words.length > 0 ? ["", mercurySlugWordsSentence(o.words)] : []),
     ].join("\n");
     return [
-        { role: "system", content: [{ type: "text", text: mercuryCardsSystem({ rooms, font }) }] },
+        { role: "system", content: [{ type: "text", text: mercuryCardsSystem({ rooms, font, poufBlocks: o.poufBlocks === true }) }] },
         { role: "user", content: [{ type: "text", text: user }] },
     ];
 }
-const CARDS_TAIL_KEYS = new Set([...Object.keys(MERCURY_CARDS_TAIL_HINTS), "rooms", "font"]);
+const CARDS_TAIL_KEYS = new Set([...Object.keys(MERCURY_CARDS_TAIL_HINTS), "rooms", "font", "archetype"]);
 const CARDS_MARKER_LINE = /^[ \t]*[*_#>-]*[ \t]*-{2,}[ \t]*CARDS[ \t]*-{2,}[ \t]*[*_]*[ \t]*$/i;
 const APP_MARKER_LINE = /^[ \t]*[*_#>-]*[ \t]*-{2,}[ \t]*APP[ \t]*-{2,}[ \t]*[*_]*[ \t]*$/i;
 const CARD_LINE = /^\s*(?:[-*•]|\d+[.)])?\s*(?:\*\*)?As an? \S/i;
@@ -807,17 +829,18 @@ export function gateMercuryCards(raw, o) {
         else if (!caps.includes(flag))
             caps.push(flag);
     }
-    const named = tailScalar(p.keys.archetype)
-        .toLowerCase()
-        .match(/[a-z]+/)?.[0] ?? "";
-    const known = MERCURY_ARCHETYPES.find((a) => a === named);
+    const named = gateMercurySkills(p.keys.skills, { poufBlocks: o.poufBlocks === true });
+    for (const u of named.unknown)
+        miss("skills", `unknown:${u.slice(0, 40)}`);
+    const known = readMercuryAppShape(tailScalar(p.keys.shape ?? p.keys.archetype));
     if (known === undefined)
-        miss("archetype", "default");
+        miss("shape", "default");
     const rShape = parseMercuryBriefShape({
-        archetype: known ?? MERCURY_CARDS_DEFAULT_ARCHETYPE,
+        appShape: known ?? MERCURY_CARDS_DEFAULT_APP_SHAPE,
         coreAction: o.personWords.trim(),
         recordNames: p.dataRecords.slice(0, 5),
         capabilities: caps,
+        skills: [...named.skills],
     }, o.personWords);
     if (rShape.isErr())
         return Result.Err(`classification:${rShape.Err().message}`);
@@ -1060,10 +1083,11 @@ export function assembleMercuryCardsCreateVibe(o) {
     const s = o.brief.shape;
     const nature = mercuryNature(s, o.personWords);
     const rooms = sanitizeRoomShortlist("pouf", o.brief.rooms?.rooms);
+    const skills = mercurySkills(s);
     return {
         prompt: o.personWords,
-        enrichedPrompt: mercuryTesterReplyEnrichedPrompt(o.reply, o.personWords, s),
-        skills: mercurySkills(s, { personWords: o.personWords }),
+        enrichedPrompt: mercuryTesterReplyEnrichedPrompt(o.reply, o.personWords, s, skills),
+        skills,
         ...(o.brief.address.pairs.length === 0 ? {} : { pairs: o.brief.address.pairs.map((p) => ({ title: p.title, slug: p.slug })) }),
         nature,
         ...(nature === "sensitive" ? { privacySensitive: true } : {}),
@@ -1085,7 +1109,7 @@ function titleFromSlug(slug) {
         .join(" ");
 }
 function looseMercuryAddress(title, slugs) {
-    const cut = stripMercuryArchetypeTag((title ?? "").trim());
+    const cut = stripMercuryShapeTag((title ?? "").trim());
     const own = cut.text.trim().replace(/^["*]+|["*]+$/g, "");
     const kept = [...new Set(slugs.map(kebab).filter((x) => x.length > 0))].slice(0, 3);
     const name = own.length > 0 && kebab(own).length > 0 ? own : kept.length > 0 ? titleFromSlug(kept[0]) : "";
@@ -1119,9 +1143,15 @@ async function mercuryCardsBriefCall(vctx, o) {
         aborted: false,
     }));
     const request = (words) => () => ({
-        messages: mercuryCardsMessages({ personWords: o.personWords, words, rooms: o.askRooms, font: o.askRooms }),
+        messages: mercuryCardsMessages({
+            personWords: o.personWords,
+            words,
+            rooms: o.askRooms,
+            font: o.askRooms,
+            poufBlocks: o.askRooms,
+        }),
     });
-    const gate = (raw) => gateMercuryCards(raw, { personWords: o.personWords, askRooms: o.askRooms });
+    const gate = (raw) => gateMercuryCards(raw, { personWords: o.personWords, askRooms: o.askRooms, poufBlocks: o.askRooms });
     const attempt = {
         call: "brief",
         deadlineMs: o.deadlineMs,