gooseworks 0.3.16 → 0.4.1

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"}

package/dist/skills/routes.d.ts

@@ -0,0 +1,68 @@
+/**
+ * THE routing table for the GooseWorks skill family (GOOSE-3190).
+ *
+ * Routing used to be written out by hand in THREE places that drifted apart:
+ *   1. this CLI's `gooseworks` router SKILL.md (`master-skill.ts`),
+ *   2. the backend's hosted-connector pointer
+ *      (`gooseworks-app/backend/src/app-mcp-server/lib/ads-skill.ts`),
+ *   3. the public skills repo's `collections/brand-growth`.
+ *
+ * This file is now the SINGLE SOURCE. `master-skill.ts` renders its markdown
+ * tables from here (no hand-written route rows), `npm run generate:skills`
+ * emits the machine-readable copy to `skills/routes.json` for the other two
+ * repos to derive from, and `tests/skills/route-drift.test.ts` fails when any
+ * of the three names a skill the others don't.
+ *
+ * The two consumers we cannot edit from this repo are represented by checked-in
+ * snapshots under `tests/fixtures/`; each snapshot names the file to update when
+ * the drift test fires.
+ */
+/** How a routed skill reaches the agent. */
+export type RouteDelivery = 
+/** Vendored by this CLI and installed to ~/.agents/skills/. */
+'entry'
+/** Lives in goose-skills; fetched on demand with `gooseworks fetch <slug>`. */
+ | 'fetch';
+export interface DomainRoute {
+    /** The skill slug to route to. */
+    skill: string;
+    /** When this route applies — the left column of the router table. */
+    when: string;
+    /** How the agent gets the skill — the right column of the router table. */
+    how: string;
+    delivery: RouteDelivery;
+}
+export interface BrandGrowthRoute {
+    /** The job to be done. */
+    job: string;
+    /** The skill slug(s) that do it, in order. */
+    skills: string[];
+}
+/**
+ * Domain routes — the "Route to the right skill FIRST" table. These are the
+ * specialist skills the `gooseworks` router hands whole tasks to.
+ */
+export declare const DOMAIN_ROUTES: DomainRoute[];
+/**
+ * Brand Growth routes — the outcome skills in the `brand-growth` collection.
+ * Must stay in sync with `goose-skills/collections/brand-growth/routes.json`,
+ * which is derived from this list.
+ */
+export declare const BRAND_GROWTH_ROUTES: BrandGrowthRoute[];
+/** Every skill slug named by any route, deduped and sorted. */
+export declare function getRoutedSkillSlugs(): string[];
+/** Brand Growth slugs only (the ones the goose-skills collection must contain). */
+export declare function getBrandGrowthSkillSlugs(): string[];
+/** The machine-readable route table emitted to `skills/routes.json`. */
+export declare function getRouteManifest(): {
+    $comment: string;
+    version: number;
+    domain_routes: DomainRoute[];
+    brand_growth_routes: BrandGrowthRoute[];
+    skills: string[];
+};
+/** Render the domain route table as the router SKILL.md markdown table body. */
+export declare function renderDomainRouteTable(): string;
+/** Render the Brand Growth job→skill table body. */
+export declare function renderBrandGrowthTable(): string;
+//# sourceMappingURL=routes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../src/skills/routes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,4CAA4C;AAC5C,MAAM,MAAM,aAAa;AACvB,+DAA+D;AAC7D,OAAO;AACT,+EAA+E;GAC7E,OAAO,CAAC;AAEZ,MAAM,WAAW,WAAW;IAC1B,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,aAAa,CAAC;CACzB;AAED,MAAM,WAAW,gBAAgB;IAC/B,0BAA0B;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,8CAA8C;IAC9C,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,EA+BtC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAAgB,EAkBjD,CAAC;AAEF,+DAA+D;AAC/D,wBAAgB,mBAAmB,IAAI,MAAM,EAAE,CAK9C;AAED,mFAAmF;AACnF,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAInD;AAED,wEAAwE;AACxE,wBAAgB,gBAAgB,IAAI;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,WAAW,EAAE,CAAC;IAC7B,mBAAmB,EAAE,gBAAgB,EAAE,CAAC;IACxC,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CASA;AAED,gFAAgF;AAChF,wBAAgB,sBAAsB,IAAI,MAAM,CAI/C;AAED,oDAAoD;AACpD,wBAAgB,sBAAsB,IAAI,MAAM,CAI/C"}

package/dist/skills/routes.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * THE routing table for the GooseWorks skill family (GOOSE-3190).
+ *
+ * Routing used to be written out by hand in THREE places that drifted apart:
+ *   1. this CLI's `gooseworks` router SKILL.md (`master-skill.ts`),
+ *   2. the backend's hosted-connector pointer
+ *      (`gooseworks-app/backend/src/app-mcp-server/lib/ads-skill.ts`),
+ *   3. the public skills repo's `collections/brand-growth`.
+ *
+ * This file is now the SINGLE SOURCE. `master-skill.ts` renders its markdown
+ * tables from here (no hand-written route rows), `npm run generate:skills`
+ * emits the machine-readable copy to `skills/routes.json` for the other two
+ * repos to derive from, and `tests/skills/route-drift.test.ts` fails when any
+ * of the three names a skill the others don't.
+ *
+ * The two consumers we cannot edit from this repo are represented by checked-in
+ * snapshots under `tests/fixtures/`; each snapshot names the file to update when
+ * the drift test fires.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BRAND_GROWTH_ROUTES = exports.DOMAIN_ROUTES = void 0;
+exports.getRoutedSkillSlugs = getRoutedSkillSlugs;
+exports.getBrandGrowthSkillSlugs = getBrandGrowthSkillSlugs;
+exports.getRouteManifest = getRouteManifest;
+exports.renderDomainRouteTable = renderDomainRouteTable;
+exports.renderBrandGrowthTable = renderBrandGrowthTable;
+/**
+ * Domain routes — the "Route to the right skill FIRST" table. These are the
+ * specialist skills the `gooseworks` router hands whole tasks to.
+ */
+exports.DOMAIN_ROUTES = [
+    {
+        skill: 'goose-ads',
+        when: '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',
+        how: 'Installed locally as an entry skill. Just use it. If unavailable, run `gooseworks install --claude`.',
+        delivery: 'entry',
+    },
+    {
+        skill: 'goose-graphics',
+        when: 'Charts, infographics, slides, social graphics, branded visual designs from a style/format',
+        how: 'If installed locally, use it. Otherwise `gooseworks fetch goose-graphics` (or `gooseworks install --claude --with goose-graphics`).',
+        delivery: 'fetch',
+    },
+    {
+        skill: 'goose-video',
+        when: 'Make a **video** ad — remix a video ad template (e.g. iMessage chat-reveal), or "make the video for project <id>"',
+        how: 'Installed locally as an entry skill. Just use it. If unavailable, run `gooseworks install --claude`.',
+        delivery: 'entry',
+    },
+    {
+        skill: 'goose-product-photos',
+        when: 'Make **product photos** — studio, lifestyle, marketplace, social, or on-model product photography',
+        how: 'Installed locally as an entry skill. Just use it. If unavailable, run `gooseworks install --claude`.',
+        delivery: 'entry',
+    },
+    {
+        skill: 'animate-image',
+        when: 'Animate an approved static ad or product image',
+        how: 'Fetch with `gooseworks fetch animate-image` and follow its GooseWorks MCP workflow.',
+        delivery: 'fetch',
+    },
+];
+/**
+ * Brand Growth routes — the outcome skills in the `brand-growth` collection.
+ * Must stay in sync with `goose-skills/collections/brand-growth/routes.json`,
+ * which is derived from this list.
+ */
+exports.BRAND_GROWTH_ROUTES = [
+    { job: 'Brand foundation', skills: ['brand-research'] },
+    { job: 'Competitor ads', skills: ['competitor-ad-intelligence'] },
+    { job: 'Customer language and angles', skills: ['comment-mining', 'ad-angle-miner'] },
+    { job: 'Competitor social content', skills: ['competitor-social-research'] },
+    { job: 'Audience definition', skills: ['audience-research'] },
+    { job: 'Creator discovery and evaluation', skills: ['influencer-prospecting', 'creator-profile-teardown'] },
+    { job: 'Trends and outlier posts', skills: ['trend-discovery', 'outlier-post-finder'] },
+    { job: 'Social listening and product demand', skills: ['social-listening-brief', 'product-demand-research'] },
+    { job: 'Long-form source material (calls, podcasts, videos)', skills: ['transcript-intelligence'] },
+    {
+        job: 'Meta performance, policy, and landing-page match',
+        skills: ['meta-ads-analyzer', 'meta-ad-policy-checker', 'ad-to-landing-page-auditor'],
+    },
+    { job: 'Static ads', skills: ['goose-ads', 'remix-graphic-ad-from-reference'] },
+    { job: 'Product photos', skills: ['goose-product-photos', 'product-photoshoot'] },
+    { job: 'Written content and repurposing', skills: ['content-repurposing'] },
+    { job: 'Graphics and animation', skills: ['goose-graphics', 'animate-image'] },
+];
+/** Every skill slug named by any route, deduped and sorted. */
+function getRoutedSkillSlugs() {
+    const slugs = new Set();
+    for (const r of exports.DOMAIN_ROUTES)
+        slugs.add(r.skill);
+    for (const r of exports.BRAND_GROWTH_ROUTES)
+        for (const s of r.skills)
+            slugs.add(s);
+    return [...slugs].sort();
+}
+/** Brand Growth slugs only (the ones the goose-skills collection must contain). */
+function getBrandGrowthSkillSlugs() {
+    const slugs = new Set();
+    for (const r of exports.BRAND_GROWTH_ROUTES)
+        for (const s of r.skills)
+            slugs.add(s);
+    return [...slugs].sort();
+}
+/** The machine-readable route table emitted to `skills/routes.json`. */
+function getRouteManifest() {
+    return {
+        $comment: 'Generated by `npm run generate:skills` from gooseworks/src/skills/routes.ts — the single source for GooseWorks skill routing (GOOSE-3190). Do not hand-edit. Consumers: goose-skills/collections/brand-growth/routes.json and gooseworks-app/backend/src/app-mcp-server/lib/ads-skill.ts.',
+        version: 1,
+        domain_routes: exports.DOMAIN_ROUTES,
+        brand_growth_routes: exports.BRAND_GROWTH_ROUTES,
+        skills: getRoutedSkillSlugs(),
+    };
+}
+/** Render the domain route table as the router SKILL.md markdown table body. */
+function renderDomainRouteTable() {
+    return exports.DOMAIN_ROUTES.map((r) => `| ${r.when} | **\`${r.skill}\`** | ${r.how} |`).join('\n');
+}
+/** Render the Brand Growth job→skill table body. */
+function renderBrandGrowthTable() {
+    return exports.BRAND_GROWTH_ROUTES.map((r) => `| ${r.job} | ${r.skills.map((s) => `\`${s}\``).join(', ')} |`).join('\n');
+}
+//# sourceMappingURL=routes.js.map

package/dist/skills/routes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.js","sourceRoot":"","sources":["../../src/skills/routes.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gooseworks",
-  "version": "0.3.16",
+  "version": "0.4.1",
   "description": "GooseWorks CLI — give your coding agent real data tools",
   "bin": {
     "gooseworks": "./dist/index.js"

package/skills/goose-ads/SKILL.md

@@ -36,6 +36,24 @@ Everything goes through the `mcp__gooseworks__*` tools. If they are not availabl
 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
@@ -161,9 +179,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.

package/skills/goose-product-photos/SKILL.md

@@ -11,7 +11,7 @@ description: >
   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.1.0
+version: 0.2.0
 author: GooseWorks
 tags: [gooseworks, ads, product-photos, photoshoot, product, ecommerce, studio, lifestyle, on-model]
 ---
@@ -32,6 +32,24 @@ Everything goes through the `mcp__gooseworks__*` tools. If they are not availabl
 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
@@ -81,10 +99,13 @@ HTTP/file fallback.
 
 ## Workflow — shoot a product
 
-1. **Resolve the brand + product.** `list_ad_brands` → `brand_id`. `list_brand_products` → pick a
-   `product_id`. If the product isn't there, `import_product` (poll `get_product_import`).
+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`.
@@ -95,6 +116,9 @@ HTTP/file fallback.
 
 - **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

package/skills/gooseworks/SKILL.md

@@ -20,7 +20,7 @@ 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 |
 | --- | --- | --- |
@@ -33,6 +33,28 @@ Before anything else, check whether the request belongs to a specialized domain.
 
 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`.
@@ -69,57 +91,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
-
-Use the host's native question controls. Keep the labels below; the values in backticks are the stable values accepted by `update_brand_onboarding`.
-
-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.
+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.
 
-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.
+Keep the user's original task pending. Call **`brand_onboarding { action: "status" }`** before routing or executing it, then:
 
-### Research while onboarding
+- 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 useful setup work, not only form collection:
+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.
 
-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.
+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.
 
-### First task
+### Shared flow
 
-Finish with **What do you want to do first?**
+Use the host's native question controls. Ask one short group at a time and rely on the live tool schema for accepted values.
 
-- 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`
+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"`.
 
-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
 
@@ -129,17 +126,20 @@ Brand Growth is a collection inside the normal skill catalog, not a command or i
 | --- | --- |
 | Brand foundation | `brand-research` |
 | Competitor ads | `competitor-ad-intelligence` |
-| Customer language and angles | `comment-mining` → `ad-angle-miner` |
+| Customer language and angles | `comment-mining`, `ad-angle-miner` |
 | Competitor social content | `competitor-social-research` |
-| Creator discovery and evaluation | `influencer-prospecting` |
+| Audience definition | `audience-research` |
+| Creator discovery and evaluation | `influencer-prospecting`, `creator-profile-teardown` |
 | Trends and outlier posts | `trend-discovery`, `outlier-post-finder` |
 | Social listening and product demand | `social-listening-brief`, `product-demand-research` |
+| Long-form source material (calls, podcasts, videos) | `transcript-intelligence` |
 | 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` |
+| Static ads | `goose-ads`, `remix-graphic-ad-from-reference` |
+| Product photos | `goose-product-photos`, `product-photoshoot` |
+| Written content and repurposing | `content-repurposing` |
 | 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.
+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
@@ -269,6 +269,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`