gooseworks 0.3.16 → 0.4.0

package/dist/skills/master-skill.js

@@ -1,17 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getEntrySkills = getEntrySkills;
+exports.getEntrySkillNames = getEntrySkillNames;
 exports.getMasterSkillContent = getMasterSkillContent;
 exports.getGooseAdsSkillContent = getGooseAdsSkillContent;
 exports.getGooseVideoSkillContent = getGooseVideoSkillContent;
-/** Every entry skill the CLI vendors + installs. */
+exports.getGooseProductPhotosSkillContent = getGooseProductPhotosSkillContent;
+/**
+ * The CLI installs two vendored ENTRY skills into ~/.agents/skills/:
+ *   - `gooseworks`  — the PARENT router (getMasterSkillContent): GTM/data toolkit
+ *     PLUS a domain router that hands ads/graphics/video work to the dedicated
+ *     `goose-*` skills below.
+ *   - `goose-ads`   — the ads entry/contract (getGooseAdsSkillContent): ad creative
+ *     (remix, brand research) AND ad analytics/intelligence. Formerly `ads-remix`.
+ * Each is a separate Claude Code skill; Claude auto-loads whichever matches the
+ * task by its description. They are domain-scoped on purpose — do NOT merge them.
+ *
+ * Sibling domain skills NOT vendored here (fetched live from goose-skills):
+ *   - `goose-graphics` — charts/slides/infographics/branded visuals. Installed via
+ *     `gooseworks install --with goose-graphics` or fetched on demand.
+ *   - `goose-video`    — video ad remix: fetches the per-format recipe by slug,
+ *     renders LOCALLY (Playwright + ffmpeg + media proxies), mirrors a script for
+ *     in-app review, saves the MP4 back over MCP (getGooseVideoSkillContent).
+ *
+ * Recipe skills (remix-graphic-ad-from-reference, brand-research, meta-ads-analyzer,
+ * …) are NOT vendored here — they live in goose-skills and are fetched live on
+ * demand via `gooseworks fetch <slug>`, so they're always current.
+ */
+const routes_1 = require("./routes");
+/**
+ * THE registry of entry skills (GOOSE-3190) — one list, four consumers:
+ *   - `gooseworks install` / `update` / login-refresh write exactly these dirs,
+ *   - `npm run generate:skills` regenerates exactly these `skills/<name>/SKILL.md`,
+ *   - `skills/names.ts` derives which dirs the CLI is allowed to delete,
+ *   - the backend raw-fetches these paths for hosted connectors.
+ *
+ * `goose-product-photos` used to be a hand-maintained `skills/…/SKILL.md` that
+ * was on disk and served by the backend but absent here — so it was never
+ * regenerated and never refreshed on install. Adding it closes that drift.
+ */
 function getEntrySkills() {
     return [
         { name: 'gooseworks', content: getMasterSkillContent() },
         { name: 'goose-ads', content: getGooseAdsSkillContent() },
         { name: 'goose-video', content: getGooseVideoSkillContent() },
+        { name: 'goose-product-photos', content: getGooseProductPhotosSkillContent() },
     ];
 }
+/** Just the directory names, for callers that don't need the bodies. */
+function getEntrySkillNames() {
+    return getEntrySkills().map((s) => s.name);
+}
 /**
  * Returns the GTM master SKILL.md content (the `gooseworks` entry skill).
  * It teaches the coding agent how to discover and use GooseWorks skills on
@@ -44,19 +83,37 @@ This skill is also the **parent router** for the GooseWorks family. Data/GTM wor
 
 ## Route to the right skill FIRST
 
-Before anything else, check whether the request belongs to a specialized domain. If so, **switch to that skill** instead of the data flow below:
+First apply the **Common company onboarding** gate below. Preserve the user's original request while onboarding, then continue with it as soon as onboarding is complete. Then load the brand context (**"Load the brand context FIRST"**, immediately below). After that, check whether the request belongs to a specialized domain. If so, **switch to that skill** instead of the data flow below:
 
 | If the user wants… | Route to | How |
 | --- | --- | --- |
-| Remix/make an ad, research a brand for ads, OR analyze ad performance — Meta/Google ad campaigns, creative fatigue, CAC/lead quality, competitor ad intel, ad angles & hooks | **\`goose-ads\`** | Installed locally as an entry skill. Just use it. If unavailable, run \`gooseworks install --claude\`. |
-| Charts, infographics, slides, social graphics, branded visual designs from a style/format | **\`goose-graphics\`** | If installed locally, use it. Otherwise \`gooseworks fetch goose-graphics\` (or \`gooseworks install --claude --with goose-graphics\`). |
-| Make a **video** ad — remix a video ad template (e.g. iMessage chat-reveal), or "make the video for project <id>" | **\`goose-video\`** | Installed locally as an entry skill. Just use it. If unavailable, run \`gooseworks install --claude\`. |
-| Make **product photos** — studio, lifestyle, marketplace, social, or on-model product photography | **\`goose-product-photos\`** | Installed locally as an entry skill. Just use it. If unavailable, run \`gooseworks install --claude\`. |
-| Animate an approved static ad or product image | **\`animate-image\`** | Fetch with \`gooseworks fetch animate-image\` and follow its GooseWorks MCP workflow. |
+${(0, routes_1.renderDomainRouteTable)()}
 | Anything else — scraping, research, lead gen, enrichment, any data lookup | (stay here) | Follow "How to Use" below. |
 
 Examples — all of these route to \`goose-ads\`, not the data flow: "remix this ad with project id 123", "make an ad for my product", "research my brand", "why is my Meta campaign underperforming", "which creatives should I cut".
 
+## Load the brand context FIRST (mandatory — before you route, and before you ask anything)
+
+**Call \`brand_get_context\` before the first substantive step of ANY task**, and before you route to a specialist skill. It is a cheap, read-only call that returns the brand's canonical facts:
+
+| It returns | Use it for |
+| --- | --- |
+| **voice** — tone, style, banned phrasing | Any copy, script, caption, hook, or headline. Don't ask "what tone?" |
+| **products** — names, descriptions, pricing, links, imagery | Picking the product to feature. Don't ask "which product?" — offer the list. |
+| **audience** — segments, demographics, jobs-to-be-done | Targeting, angles, creator fit. Don't ask "who is this for?" |
+| **positioning** — category, value props, proof points, tagline | Angles, offers, competitive framing. Don't ask "what makes you different?" |
+| **research status** — whether the brand's research pass has completed | Whether the facts are trustworthy yet, or still being filled in. |
+
+Then:
+
+1. **Pass what it returned INTO the routed skill.** When you hand off to \`goose-ads\`, \`goose-video\`, \`goose-product-photos\`, \`goose-graphics\`, or a fetched Brand Growth recipe, carry the voice / products / audience / positioning with you. Do **not** make the routed skill re-derive them, and do **not** re-run brand research when the context is already there.
+2. **Never re-ask the user for something the brand context already answers.** If a routed skill's own prose asks a question the context answers, the context wins — answer it yourself and move on. Ask only for what is genuinely missing or ambiguous.
+3. **If research status is not complete**, say so in one line, use what you have, and continue. Only run brand research when the context comes back empty or the user asks for it.
+4. **If \`brand_get_context\` is unavailable** (no MCP connection), fall back to \`get_brand_kit\` for the selected brand and treat its fields the same way. If neither is available, tell the user the GooseWorks MCP connection is needed rather than guessing brand facts.
+5. **Treat it as read-only.** Writing brand facts back is the reconciliation flow in \`goose-ads\` (ask first, then \`update_brand_kit\`) — not something this router does.
+
+Never invent a brand fact. If it isn't in the brand context and the user hasn't said it, ask.
+
 ## Setup
 
 All commands below auto-load credentials from \`~/.gooseworks/credentials.json\`. If a command exits with "Not logged in", tell the user to run: \`npx gooseworks login\`. To log out: \`npx gooseworks logout\`.
@@ -93,57 +150,32 @@ gooseworks credits
 
 ## Common company onboarding
 
-Onboarding is voluntary and happens inside the current coding agent. Run it when the user explicitly says **\`/gooseworks onboard me\`**, or ask for one missing answer when it is necessary for the task in front of you. **Never force an existing user through onboarding after an update.**
-
-The CLI and GooseWorks Ads share one brand-scoped questionnaire through these MCP tools:
-
-- \`list_ad_brands\` and \`create_ad_brand\` — select or create the company/brand.
-- \`get_brand_onboarding { brand_id }\` — load completed answers and \`missing_fields\` before asking anything.
-- \`update_brand_onboarding { brand_id, ...answers }\` — save each group of answers and the final first-task choice.
-
-If these tools are unavailable, tell the user that onboarding needs the GooseWorks MCP connection. Do not send them to another UI and do not fall back to a separate context record.
-
-### Resume rules
-
-1. Run \`list_ad_brands\`. If there are multiple brands, ask which one to use.
-2. If there is no brand, ask for the company or brand website, research it, and use \`create_ad_brand { name, website_url }\`. If the domain matches an existing brand, reuse it.
-3. Call \`get_brand_onboarding\` and ask only the returned missing questions.
-4. Save after each small group so an interrupted interview can resume.
-5. If the record is complete, confirm the brand and continue; do not repeat the interview.
-
-### Shared questions and answer values
+Onboarding happens inside the current agent and is the first-run gate for every GooseWorks task. It uses the exact same saved state and step order as the web onboarding. The user does not need to type **\`/gooseworks onboard me\`**; that explicit command only starts or resumes the same flow.
 
-Use the host's native question controls. Keep the labels below; the values in backticks are the stable values accepted by \`update_brand_onboarding\`.
+Keep the user's original task pending. Call **\`brand_onboarding { action: "status" }\`** before routing or executing it, then:
 
-1. **What is your role?** Founder / Business Owner · C-Suite · VP / Director · Performance / Growth Marketing · Brand / Content Marketing · Creative / Design · Agency · Consultant / Freelancer · Other.
-2. **How much do you spend on paid ads right now?** \`zero\` · \`under_10k\` · \`10k_30k\` · \`30k_100k\` · \`100k_plus\`.
-3. **What are your goals?** Multi-select: create ads \`make_creatives\` · analyze ads \`analyze_ads\` · manage/optimize ads \`ai_manage\` · competitor or customer research \`research_competitors\` · creators and social trends \`creators_trends\` · content \`content_growth\` · lead generation \`lead_generation\` · data work \`data_work\` · work with an expert team \`expert_team\`.
-4. **Who makes your ad creatives right now?** and **Who manages your ads right now?** Use the shared values returned in the tool schema. Skip both when ad spend is \`zero\` and no advertising goal was selected.
-5. **Which platforms or channels do you use or want help with?** Multi-select: \`meta\` · \`tiktok\` · \`google\` · \`chatgpt\` · \`x\` · \`linkedin\` · \`reddit\` · \`other\`.
-6. **Where did you find GooseWorks?** Use the shared discovery-source values returned in the tool schema.
+- follow only the returned \`next_step\`;
+- save each answer immediately with \`brand_onboarding\` so web, Claude, Codex, ChatGPT, and Cowork can resume one another;
+- continue the original request immediately when \`onboarding_completed\` is true.
 
-Do not add CLI-only questions about business type, products, or audience. Infer them from the website and ask one clarification only when the research is materially uncertain.
+If \`brand_onboarding\` is unavailable, explain that the GooseWorks MCP connection must be enabled. Do not write a parallel local profile and do not run the retired role / discovery-source / ad-owner questionnaire.
 
-### Research while onboarding
+When onboarding returns a review link, show that single link and ask the user to review the creatives and reply \`done\`. When they reply \`done\`, do not restart onboarding: continue the task they originally asked for. If there was no earlier task, ask: **“Let’s start your next campaign. What are you promoting, and what result do you want?”** Use the same preserved-task-or-campaign handoff if onboarding completes while the creatives are still being prepared or could not be generated.
 
-Do useful setup work, not only form collection:
+### Shared flow
 
-1. Fetch \`brand-research\` and research the website, products/services, audiences, competitors, offers, and messaging evidence.
-2. Reuse existing Brand Kit/Core data. For an ecommerce store, import the relevant catalog with \`import_product\` and poll \`get_product_import\` rather than submitting duplicates.
-3. When ads are relevant, offer to import existing creative. This is optional.
-4. Suggest evidence-backed messaging angles. Approval is optional and never blocks completion.
-5. Show the researched profile for confirmation: products/services, audience, competitors, imported ads, and suggested angles. Clearly label uncertainty.
+Use the host's native question controls. Ask one short group at a time and rely on the live tool schema for accepted values.
 
-### First task
+1. **Start** — If status returns \`start\`, ask for the company website or Apple App Store URL. Also offer the optional hero product URL and “Where do you do your work?” choices: Slack, WhatsApp, iMessage, Claude Code, Claude, Codex, and ChatGPT. Call \`action: "start"\`; server-side research begins immediately. If status returns \`select_brand\`, ask which company/client to use. Otherwise reuse the only brand automatically.
+2. **Your coworker** — Ask what they want to name their Growth Coworker. A text-only client may keep the default avatar; do not block on an image. Save with \`action: "save_coworker"\`.
+3. **Your company** — Use the returned \`company_draft\` as the starting point and ask the user to verify or edit: what they sell (\`marketCategory\`), where people buy (\`appPlatforms\`), primary customer, customer problem, promised outcome, and optional differentiator. Save with \`action: "save_company"\`.
+4. **Your taste** — In a terminal or CLI host, use the returned \`taste_url\`: open it when the host supports opening links and always show one clickable **Choose your taste in GooseWorks** link. Ask the user to heart or skip ads on that page, click **Continue** or **Skip this**, return to the agent, and reply \`done\`. Do not print, enumerate, or summarize \`taste_deck\` in the terminal. After \`done\`, call \`brand_onboarding { action: "status" }\` again and follow the refreshed \`next_step\`. In a chat host that renders images, show only the one image attached by the tool and save each Love/Skip decision with \`action: "save_taste"\`; send \`complete: true\` after three hearts or an explicit skip.
+5. **First campaign** — Ask **“What’s happening right now?”**: launch \`launch\`, promotion \`promo\`, seasonal moment \`seasonal\`, or nothing special \`nothing\`, plus an optional note. Call \`action: "propose_campaign"\`, show the returned editable card (name, objective, offer, audience, 2–3 angles, CTA, and product URL), and save edits with \`action: "save_campaign"\`. Send \`accept: true\` only after approval; acceptance can start the complimentary first creatives.
+6. **Where you are** — Ask monthly ad spend (\`none\`, \`under_1k\`, \`1k_5k\`, \`5k_25k\`, \`25k_plus\`), annual revenue (\`under_1m\`, \`1m_10m\`, \`10m_100m\`, \`100m_plus\`), the 90-day goal, current channels (an empty list is a valid “nothing yet”), and at least one channel they are willing to use. Channel values: \`paid_social\`, \`search_ads\`, \`content\`, \`creators\`, \`seo\`, \`communities\`, \`referrals\`, \`partnerships\`, \`outbound\`, \`app_stores\`, \`other\`. Save with \`action: "save_progress"\`.
+7. **Review** — Show the returned founder, researched, and inferred facts with their provenance. The user may correct positioning, audience, voice, value propositions, proof points, or competitors through \`action: "review_research"\`. Complete the review even when research is still running, failed, or sparse; never trap the user waiting for it.
+8. **Channels** — If \`channel_connected\` is already true, this is complete automatically. Otherwise ask whether they want to connect Slack, WhatsApp, or iMessage later, or skip for now. An explicit skip is valid; call \`action: "complete_channels"\`.
 
-Finish with **What do you want to do first?**
-
-- Connect my tools and data — \`connect_tools\`
-- Research customers, competitors, creators, or trends — \`research\`
-- Analyze ads, content, landing pages, or performance — \`analyze\`
-- Create ads, product images, or social content — \`create\`
-
-Save the choice as \`first_task\`, then start that job. If the user already stated a concrete job, save the matching value and start without showing the menu.
+Do not ask for role, discovery source, who makes creatives, who manages ads, or a separate “what do you want to do first?” menu. Those belonged to the retired CLI questionnaire. The task the user already asked for is their first task.
 
 ## Brand Growth discovery
 
@@ -151,19 +183,9 @@ Brand Growth is a collection inside the normal skill catalog, not a command or i
 
 | Job | Skill |
 | --- | --- |
-| Brand foundation | \`brand-research\` |
-| Competitor ads | \`competitor-ad-intelligence\` |
-| Customer language and angles | \`comment-mining\` → \`ad-angle-miner\` |
-| Competitor social content | \`competitor-social-research\` |
-| Creator discovery and evaluation | \`influencer-prospecting\` |
-| Trends and outlier posts | \`trend-discovery\`, \`outlier-post-finder\` |
-| Social listening and product demand | \`social-listening-brief\`, \`product-demand-research\` |
-| Meta performance, policy, and landing-page match | \`meta-ads-analyzer\`, \`meta-ad-policy-checker\`, \`ad-to-landing-page-auditor\` |
-| Static ads | \`goose-ads\` / \`remix-graphic-ad-from-reference\` |
-| Product photos | \`goose-product-photos\` |
-| Graphics and animation | \`goose-graphics\`, \`animate-image\` |
-
-Fetch the named public skill before following it. Provider helpers such as \`scrapecreators-api\` and \`transcript-intelligence\` are dependencies, not user-facing results.
+${(0, routes_1.renderBrandGrowthTable)()}
+
+Fetch the named public skill before following it. You already called \`brand_get_context\` — hand the brand's voice, products, audience, and positioning to the fetched skill instead of letting it re-derive or re-ask them. Provider helpers such as \`scrapecreators-api\` and \`transcript-intelligence\` are dependencies, not user-facing results.
 
 For a multi-part request, repeat this routing check before each new job. Fetch and follow the
 closest outcome skill first (for example, \`comment-mining\`, \`creator-profile-teardown\`, or
@@ -293,6 +315,7 @@ The \`gooseworks\` CLI sends authenticated requests (Bearer \`GOOSEWORKS_API_KEY
 
 ## Rules
 
+0. **Call \`brand_get_context\` before anything else**, pass what it returns into whatever skill you route to, and never re-ask the user for a fact it already answers (see "Load the brand context FIRST").
 1. **Consider a GooseWorks skill when it fits the task** — scraping, research, lead gen, enrichment, especially at scale, behind auth, or from a specific source. For a quick lookup your built-in tools are fine; use your judgement and pick the best tool for the user.
 2. **Before paid operations**, tell the user the estimated credit cost
 3. **If a \`gooseworks\` command exits with "Not logged in"**: tell the user to run \`npx gooseworks login\`
@@ -356,6 +379,24 @@ Everything goes through the \`mcp__gooseworks__*\` tools. If they are not availa
 tell the user to run \`gooseworks install --claude --mcp\`** (and restart Claude Code). There is
 no HTTP/file fallback — the REST ad endpoints are session-cookie-only and reject your token.
 
+## Start from the brand context — don't re-ask what it already answers
+
+If the \`gooseworks\` router handed you brand context, USE IT. If you were invoked directly, call
+\`brand_get_context\` first (falling back to \`get_brand_kit\` for the selected brand). It already
+answers most of what the flows below would otherwise ask the user:
+
+- **Which product to feature** → \`products[]\`. Offer the real catalog entries; never guess a
+  product name and never ask the user to list their products.
+- **The vibe / tone of the copy** → the brand's **voice**. Use it; don't ask "what tone?".
+- **Who the ad is for** → the brand's **audience**. Don't ask "who's the target?".
+- **The angle, offer framing, and what to claim** → **positioning**, value props, proof points.
+- **Logo, colors, fonts** → owned by the backend research pass. **Never re-derive them.**
+- **Whether the facts are trustworthy yet** → **research status**. If it isn't complete, say so in
+  one line and continue; the batch queues and runs when research finishes.
+
+Ask only for what the context genuinely doesn't answer: the specific campaign intent (season,
+promo, which of several angles), the source ad, and anything the user must consent to.
+
 ## Identity & credits
 
 - One agent-scoped token authenticates the \`gooseworks\` MCP tools. Never print it. The tools
@@ -481,9 +522,11 @@ When the user wants to make ads but has NOT named a specific template (id/slug/C
 ad/upload), do NOT silently browse the raw catalog and hand-pick for them. Instead run this
 short ask flow — it mirrors the web app and keeps the human in the loop:
 
-1. **Ask what kind of ads they want** — the angle/offer/theme/season, the vibe, and which
-   product from the brand kit to feature. This shapes both the source choice and your steering
-   \`prompt\`. Keep it to one or two quick questions.
+1. **Ask what kind of ads they want** — the angle/offer/theme/season. **The brand context already
+   gives you the vibe (voice), the audience, and the product catalog — do NOT ask for those.**
+   Offer the real \`products[]\` to pick from rather than asking "which product?", and derive the
+   tone from the brand's voice. This shapes both the source choice and your steering \`prompt\`.
+   Keep it to one quick question about campaign intent.
 2. **Ask how to pick a source: their own ads, Community, upload, or "Surprise me".**
    - **Their own ads** → use \`list_user_ad_templates\` to load the active brand's own sources and
      let them choose from the results.
@@ -1104,4 +1147,146 @@ path. (\`fal-storage-proxy\` may 404 depending on the install; don't block on it
 - Always end a successful run with \`app_url\` + \`brand_url\`, verbatim.
 `;
 }
+/**
+ * Returns the goose-product-photos entry SKILL.md content.
+ *
+ * GOOSE-3190: this skill already existed on disk (`skills/goose-product-photos/
+ * SKILL.md`, hand-maintained) and was already served by the backend to hosted
+ * connectors — but it was NOT in `getEntrySkills()`, so `npm run generate:skills`
+ * never regenerated it and `install` / `update` / login-refresh never wrote or
+ * refreshed it on a user's machine. Moving the body here makes the registry the
+ * one source: one command emits all four entry skills.
+ */
+function getGooseProductPhotosSkillContent() {
+    return `---
+name: goose-product-photos
+slug: goose-product-photos
+description: >
+  GooseWorks Product Photos — turn a brand's product images into publish-ready photography
+  (clean studio shots, lifestyle scenes, on-model looks) while keeping the product faithful
+  (silhouette, materials, logo, colorway). You pick a brand + product and submit; the GooseWorks
+  backend runs the SAME server-side pipeline the Product Photos studio uses (compose → generate →
+  judge → auto-retry) and bills credits. Use when the user says "make product photos", "shoot my
+  product", "studio/lifestyle/on-model photo of <product>", "generate product photography", or
+  references a product to photograph. Unlike goose-ads (ad creative) this produces clean PRODUCT
+  photos that can then feed the ad workflow.
+category: ads
+version: 0.2.0
+author: GooseWorks
+tags: [gooseworks, ads, product-photos, photoshoot, product, ecommerce, studio, lifestyle, on-model]
+---
+
+# GooseWorks Product Photos — branded product photography
+
+The GooseWorks Product Photos skill. You **pick a brand + product and submit one generation**;
+the **backend** runs the whole pipeline (compose the shot prompt → generate on \`gpt_image_2\` →
+judge for product fidelity → auto-retry a few times for free) and stores the results. You do NOT
+generate images, call a model, or manage files — this is the exact same workflow the Product
+Photos studio uses, so the skill and the app can never drift. The point is to **enrich a brand's
+usable product imagery** — approved photos join the brand kit and can then feed the ad workflow
+(\`goose-ads\`).
+
+## Prerequisite — the GooseWorks MCP server is REQUIRED
+
+Everything goes through the \`mcp__gooseworks__*\` tools. If they are not available, **stop and
+tell the user to run \`gooseworks install --claude --mcp\`** (and restart Claude Code). There is no
+HTTP/file fallback.
+
+## Start from the brand context — don't re-ask what it already answers
+
+If the \`gooseworks\` router handed you brand context, USE IT. If you were invoked directly, call
+\`brand_get_context\` yourself first. It answers most of the setup questions below, so **do not ask
+the user for them**:
+
+- **Which product?** — the context's \`products[]\` are the real catalog entries. Offer them; never
+  invent a product or ask the user to describe one you can already see.
+- **What does it look like / what is it made of?** — grounded in the product's stored images and
+  description. Never guess a material, colorway, or silhouette.
+- **What vibe / who is it for?** — the context's voice, positioning, and audience already say. Let
+  them shape the scene and styling instead of asking "what mood do you want?".
+- **Brand look** — logo, colors, and fonts are owned by the backend research pass. Read them, never
+  re-derive them.
+
+Ask only for the genuinely open choices: the shot \`category\`, how many photos, quality, and
+whether a human model is wanted (which needs explicit consent — see the rules).
+
+## Identity & credits
+
+- One agent-scoped token authenticates the tools; they resolve your org automatically. Never
+  print the token. (You may pass an optional \`target\` to operate on a specific agent/org, exactly
+  as the other GooseWorks tools; omit it to use your pinned scope.)
+- **Credits are handled by the backend.** \`generate_product_photos\` reserves the estimated cost up
+  front and bills only the photos that pass the judge — **automatic retries are free**, and a photo
+  the judge can't get right (\`flagged\`) is shown but **never billed**. Call
+  \`estimate_product_photos\` first to quote the cost; \`get_ad_credits\` shows the balance.
+
+## The tools
+
+**Pick the brand + product**
+- \`list_ad_brands\` — the user's ad brands (get a \`brand_id\`; also carries \`slug\`).
+- \`list_brand_products { brand_id, search?, page?, page_size? }\` — the brand's imported products.
+  Pick a \`product_id\` to shoot. \`search\` matches name / type / variant / SKU.
+- \`import_product { brand_id, kind, url, product_name? }\` — import a product if it isn't in the
+  catalog yet. \`kind\` is \`product_url\` (a single product page), \`shopify_store\` (a store URL →
+  imports the catalog), or \`image_url\` (a direct image; requires \`product_name\`). Returns an import
+  row with an \`id\`; if its \`status\` isn't \`complete\`, poll \`get_product_import\` until it is, then
+  \`list_brand_products\` to find the new product. (File uploads aren't available over MCP — use a URL.)
+- \`get_product_import { import_id }\` — poll an import until \`status\` is \`complete\` or \`failed\`.
+
+**Generate**
+- \`estimate_product_photos { count, quality? }\` — cost preview (per-photo + total credits). \`count\`
+  is 1, 2, 4, or 8; \`quality\` is \`low\` | \`medium\` | \`high\` (default \`medium\`). Reserves nothing.
+- \`generate_product_photos { brand_id, product_id, variant_id?, category, controls?, prompt?,
+  count?, quality?, reference_image_urls?, attestation_accepted? }\` — **the one call that makes
+  photos.** \`category\` is \`apparel\` | \`beauty\` | \`cpg\` (seeds sensible scene/framing defaults).
+  Omit \`controls\` to use the category preset; pass \`prompt\` as free-text steering **added on top of**
+  the settings (it doesn't replace them). Returns a generation with an \`id\` **immediately** — poll
+  \`get_product_photo_generation\` until done, then read each \`outputs[].final_image_url\`.
+  **If you request a human model** (\`controls.model.presence\` is not \`none\`) you MUST pass
+  \`attestation_accepted: true\` to confirm the user has the rights for model imagery.
+- \`get_product_photo_generation { generation_id }\` — poll until \`status\` is \`complete\`,
+  \`partial_failure\`, or \`failed\`. Each \`outputs[]\` entry has its own \`status\` and, once ready, a
+  \`final_image_url\`. A \`flagged\` output is the best attempt but wasn't billed.
+
+**Use the results**
+- \`list_product_photos { brand_id, archived? }\` — the brand's generated photos (\`archived: false\`
+  = active, \`true\` = archived).
+- \`approve_product_photo { output_id }\` — approve a photo: links it to the product and makes it
+  available in the **brand kit**, so \`goose-ads\` can use it. **Photos are not used anywhere until
+  approved.**
+- \`archive_product_photo { output_id, reason? }\` — archive a photo; archived photos are **excluded**
+  from ad generation.
+
+## Workflow — shoot a product
+
+1. **Load the brand context** (\`brand_get_context\`, or reuse what the router passed you) and
+   **resolve the brand + product.** \`list_ad_brands\` → \`brand_id\`. \`list_brand_products\` → pick a
+   \`product_id\` from the catalog you already know about. If the product genuinely isn't there,
+   \`import_product\` (poll \`get_product_import\`).
+2. **Quote the cost.** \`estimate_product_photos { count, quality }\` → tell the user credits.
+3. **Generate.** \`generate_product_photos { brand_id, product_id, category, count, quality, prompt? }\`.
+   Build \`prompt\` from the brand's voice/positioning you already have — don't interview the user for it.
+   Returns a generation \`id\` right away.
+4. **Poll.** \`get_product_photo_generation { generation_id }\` until terminal; hand back each
+   \`final_image_url\`.
+5. **Approve the keepers.** Show the results and let the user pick; \`approve_product_photo\` the ones
+   they'd publish (that's what puts them in the brand kit for ads), \`archive_product_photo\` the rest.
+
+## Rules
+
+- **Never invent product facts.** The backend grounds the shot on the product's real images; don't
+  describe a product you can't see.
+- **Use the brand context instead of interviewing the user.** Product, audience, voice, positioning,
+  logo/colors/fonts all come from \`brand_get_context\` / the brand kit. Ask only for the shot
+  category, count, quality, and model consent.
+- **Ask before spending.** Quote the estimate and confirm \`count\` / \`quality\` before
+  \`generate_product_photos\` — it reserves credits.
+- **Poll, don't re-submit.** A generation that's still \`running\` is not stuck; re-submitting
+  double-bills. Only a \`failed\` generation should be retried.
+- **Model imagery needs consent.** Only set a human model when the user asks, and pass
+  \`attestation_accepted: true\`.
+- **Approval is the hand-off to ads.** Remind the user that only **approved** photos reach the brand
+  kit / ad workflow; archived ones never do.
+`;
+}
 //# sourceMappingURL=master-skill.js.map

package/dist/skills/master-skill.js.map

@@ -1 +1 @@
-{"version":3,"file":"master-skill.js","sourceRoot":"","sources":["../../src/skills/master-skill.ts"],"names":[],"mappings":";;AA4BA,wCAMC;AAWD,sDAwRC;AAiBD,0DA0UC;AAcD,8DA2bC;AA9kCD,oDAAoD;AACpD,SAAgB,cAAc;IAC5B,OAAO;QACL,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,qBAAqB,EAAE,EAAE;QACxD,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,uBAAuB,EAAE,EAAE;QACzD,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,yBAAyB,EAAE,EAAE;KAC9D,CAAC;AACJ,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsRR,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,uBAAuB;IACrC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwUR,CAAC;AACF,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,yBAAyB;IACvC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAybR,CAAC;AACF,CAAC"}
+{"version":3,"file":"master-skill.js","sourceRoot":"","sources":["../../src/skills/master-skill.ts"],"names":[],"mappings":";;AAwCA,wCAOC;AAGD,gDAEC;AAWD,sDAwQC;AAiBD,0DA8VC;AAcD,8DA2bC;AAYD,8EAmIC;AA9wCD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,qCAA0E;AAQ1E;;;;;;;;;;GAUG;AACH,SAAgB,cAAc;IAC5B,OAAO;QACL,EAAE,IAAI,EAAE,YAAY,EAAE,OAAO,EAAE,qBAAqB,EAAE,EAAE;QACxD,EAAE,IAAI,EAAE,WAAW,EAAE,OAAO,EAAE,uBAAuB,EAAE,EAAE;QACzD,EAAE,IAAI,EAAE,aAAa,EAAE,OAAO,EAAE,yBAAyB,EAAE,EAAE;QAC7D,EAAE,IAAI,EAAE,sBAAsB,EAAE,OAAO,EAAE,iCAAiC,EAAE,EAAE;KAC/E,CAAC;AACJ,CAAC;AAED,wEAAwE;AACxE,SAAgB,kBAAkB;IAChC,OAAO,cAAc,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;AAC7C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,qBAAqB;IACnC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;EA0BP,IAAA,+BAAsB,GAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgGxB,IAAA,+BAAsB,GAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4IzB,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,SAAgB,uBAAuB;IACrC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4VR,CAAC;AACF,CAAC;AAED;;;;;;;;;;;GAWG;AACH,SAAgB,yBAAyB;IACvC,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAybR,CAAC;AACF,CAAC;AAED;;;;;;;;;GASG;AACH,SAAgB,iCAAiC;IAC/C,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiIR,CAAC;AACF,CAAC"}

package/dist/skills/names.d.ts

@@ -1,2 +1,54 @@
-export declare function isManagedGooseworksSkill(name: string): boolean;
+/**
+ * Which directories under ~/.agents/skills/ the CLI is allowed to DELETE.
+ *
+ * GOOSE-3191 (data loss): this predicate used to match ANY directory whose name
+ * started with `goose-` or `gooseworks-`. `gooseworks install` calls
+ * `removeAllSkills()` on every install / update / login-refresh, so a user's own
+ * unrelated third-party skill — `goose-notes`, `goose-jira`, anything they wrote
+ * themselves — was silently destroyed. A name prefix is NOT ownership.
+ *
+ * The rule now, in order of authority:
+ *
+ *   1. **Known entry-skill slugs** (`gooseworks`, `goose-ads`, `goose-video`,
+ *      `goose-product-photos`, plus the legacy `ads-remix` name) are ours by
+ *      definition — they are the dirs the CLI itself writes on every install, so
+ *      we delete them regardless of whether they carry a stamp. This is what
+ *      keeps upgrades from an old CLI working.
+ *   2. **A `.gooseworks-version` stamp** marks a directory the installer wrote.
+ *      It is a SECONDARY signal, used to recognise standalone skills installed
+ *      with `--with <slug>` (whose slugs we can't enumerate ahead of time).
+ *   3. **Anything else is the user's.** An unstamped directory that is not a
+ *      known entry slug is NEVER deleted, no matter what it's called.
+ *
+ * Deliberate, documented trade-off: a standalone skill installed by an OLDER CLI
+ * (before `installStandaloneSkill` wrote a stamp) is unstamped and therefore no
+ * longer removed by `removeAllSkills()`. That is the safe direction to be wrong —
+ * it leaves a stale-but-working copy on disk instead of deleting a stranger's
+ * work — and it self-heals: re-running `gooseworks install --with <slug>`
+ * replaces the directory in place and stamps it.
+ */
+/** The stamp file `installEntrySkill` / `installStandaloneSkill` write. */
+export declare const STAMP_FILE = ".gooseworks-version";
+/**
+ * Entry-skill dir names the CLI no longer writes but must still clean up.
+ * `ads-remix` was renamed to `goose-ads`.
+ */
+export declare const LEGACY_ENTRY_SKILL_NAMES: readonly ["ads-remix"];
+/**
+ * Every skill directory name the CLI itself owns and writes. Derived from
+ * `getEntrySkills()` so the registry stays the single source (GOOSE-3190).
+ */
+export declare function getManagedEntrySkillNames(): string[];
+/** True when `name` is a skill directory the CLI itself installs. */
+export declare function isManagedEntrySkillName(name: string): boolean;
+/** True when `<skillsBase>/<name>/.gooseworks-version` exists. */
+export declare function hasGooseworksStamp(skillsBase: string, name: string): boolean;
+/**
+ * True when the CLI may manage (link, list, and DELETE) `<skillsBase>/<name>/`.
+ *
+ * `skillsBase` is required: ownership is a property of what's ON DISK, not of
+ * the name. Callers that only have a name (e.g. pruning symlinks in
+ * ~/.claude/skills) pass the skills base the links point into.
+ */
+export declare function isManagedGooseworksSkill(name: string, skillsBase: string): boolean;
 //# sourceMappingURL=names.d.ts.map

package/dist/skills/names.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/skills/names.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAS9D"}
+{"version":3,"file":"names.d.ts","sourceRoot":"","sources":["../../src/skills/names.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,2EAA2E;AAC3E,eAAO,MAAM,UAAU,wBAAwB,CAAC;AAEhD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,wBAAyB,CAAC;AAE/D;;;GAGG;AACH,wBAAgB,yBAAyB,IAAI,MAAM,EAAE,CAEpD;AAED,qEAAqE;AACrE,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED,kEAAkE;AAClE,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAM5E;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAGlF"}

package/dist/skills/names.js

@@ -1,12 +1,112 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.LEGACY_ENTRY_SKILL_NAMES = exports.STAMP_FILE = void 0;
+exports.getManagedEntrySkillNames = getManagedEntrySkillNames;
+exports.isManagedEntrySkillName = isManagedEntrySkillName;
+exports.hasGooseworksStamp = hasGooseworksStamp;
 exports.isManagedGooseworksSkill = isManagedGooseworksSkill;
-function isManagedGooseworksSkill(name) {
-    return (name === 'gooseworks' ||
-        // `ads-remix` was renamed to `goose-ads`; keep it managed so a stale
-        // ads-remix dir from an older install is cleaned up on the next install.
-        name === 'ads-remix' ||
-        name.startsWith('gooseworks-') ||
-        name.startsWith('goose-'));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const master_skill_1 = require("./master-skill");
+/**
+ * Which directories under ~/.agents/skills/ the CLI is allowed to DELETE.
+ *
+ * GOOSE-3191 (data loss): this predicate used to match ANY directory whose name
+ * started with `goose-` or `gooseworks-`. `gooseworks install` calls
+ * `removeAllSkills()` on every install / update / login-refresh, so a user's own
+ * unrelated third-party skill — `goose-notes`, `goose-jira`, anything they wrote
+ * themselves — was silently destroyed. A name prefix is NOT ownership.
+ *
+ * The rule now, in order of authority:
+ *
+ *   1. **Known entry-skill slugs** (`gooseworks`, `goose-ads`, `goose-video`,
+ *      `goose-product-photos`, plus the legacy `ads-remix` name) are ours by
+ *      definition — they are the dirs the CLI itself writes on every install, so
+ *      we delete them regardless of whether they carry a stamp. This is what
+ *      keeps upgrades from an old CLI working.
+ *   2. **A `.gooseworks-version` stamp** marks a directory the installer wrote.
+ *      It is a SECONDARY signal, used to recognise standalone skills installed
+ *      with `--with <slug>` (whose slugs we can't enumerate ahead of time).
+ *   3. **Anything else is the user's.** An unstamped directory that is not a
+ *      known entry slug is NEVER deleted, no matter what it's called.
+ *
+ * Deliberate, documented trade-off: a standalone skill installed by an OLDER CLI
+ * (before `installStandaloneSkill` wrote a stamp) is unstamped and therefore no
+ * longer removed by `removeAllSkills()`. That is the safe direction to be wrong —
+ * it leaves a stale-but-working copy on disk instead of deleting a stranger's
+ * work — and it self-heals: re-running `gooseworks install --with <slug>`
+ * replaces the directory in place and stamps it.
+ */
+/** The stamp file `installEntrySkill` / `installStandaloneSkill` write. */
+exports.STAMP_FILE = '.gooseworks-version';
+/**
+ * Entry-skill dir names the CLI no longer writes but must still clean up.
+ * `ads-remix` was renamed to `goose-ads`.
+ */
+exports.LEGACY_ENTRY_SKILL_NAMES = ['ads-remix'];
+/**
+ * Every skill directory name the CLI itself owns and writes. Derived from
+ * `getEntrySkills()` so the registry stays the single source (GOOSE-3190).
+ */
+function getManagedEntrySkillNames() {
+    return [...(0, master_skill_1.getEntrySkillNames)(), ...exports.LEGACY_ENTRY_SKILL_NAMES];
+}
+/** True when `name` is a skill directory the CLI itself installs. */
+function isManagedEntrySkillName(name) {
+    return getManagedEntrySkillNames().includes(name);
+}
+/** True when `<skillsBase>/<name>/.gooseworks-version` exists. */
+function hasGooseworksStamp(skillsBase, name) {
+    try {
+        return fs.existsSync(path.join(skillsBase, name, exports.STAMP_FILE));
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * True when the CLI may manage (link, list, and DELETE) `<skillsBase>/<name>/`.
+ *
+ * `skillsBase` is required: ownership is a property of what's ON DISK, not of
+ * the name. Callers that only have a name (e.g. pruning symlinks in
+ * ~/.claude/skills) pass the skills base the links point into.
+ */
+function isManagedGooseworksSkill(name, skillsBase) {
+    if (isManagedEntrySkillName(name))
+        return true;
+    return hasGooseworksStamp(skillsBase, name);
 }
 //# sourceMappingURL=names.js.map

package/dist/skills/names.js.map

@@ -1 +1 @@
-{"version":3,"file":"names.js","sourceRoot":"","sources":["../../src/skills/names.ts"],"names":[],"mappings":";;AAAA,4DASC;AATD,SAAgB,wBAAwB,CAAC,IAAY;IACnD,OAAO,CACL,IAAI,KAAK,YAAY;QACrB,qEAAqE;QACrE,yEAAyE;QACzE,IAAI,KAAK,WAAW;QACpB,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC;QAC9B,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAC1B,CAAC;AACJ,CAAC"}
+{"version":3,"file":"names.js","sourceRoot":"","sources":["../../src/skills/names.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,8DAEC;AAGD,0DAEC;AAGD,gDAMC;AASD,4DAGC;AA3ED,uCAAyB;AACzB,2CAA6B;AAC7B,iDAAoD;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,2EAA2E;AAC9D,QAAA,UAAU,GAAG,qBAAqB,CAAC;AAEhD;;;GAGG;AACU,QAAA,wBAAwB,GAAG,CAAC,WAAW,CAAU,CAAC;AAE/D;;;GAGG;AACH,SAAgB,yBAAyB;IACvC,OAAO,CAAC,GAAG,IAAA,iCAAkB,GAAE,EAAE,GAAG,gCAAwB,CAAC,CAAC;AAChE,CAAC;AAED,qEAAqE;AACrE,SAAgB,uBAAuB,CAAC,IAAY;IAClD,OAAO,yBAAyB,EAAE,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;AACpD,CAAC;AAED,kEAAkE;AAClE,SAAgB,kBAAkB,CAAC,UAAkB,EAAE,IAAY;IACjE,IAAI,CAAC;QACH,OAAO,EAAE,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,kBAAU,CAAC,CAAC,CAAC;IAChE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,wBAAwB,CAAC,IAAY,EAAE,UAAkB;IACvE,IAAI,uBAAuB,CAAC,IAAI,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/C,OAAO,kBAAkB,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC;AAC9C,CAAC"}