@growthub/cli 0.7.8 → 0.8.0

package/assets/worker-kits/growthub-video-use-studio-v1/runtime-assumptions.md

@@ -0,0 +1,9 @@
+# Runtime Assumptions
+
+- Upstream project: `https://github.com/browser-use/video-use`
+- Python `>=3.11` with `pip` available
+- `ffmpeg` available in PATH (required)
+- `yt-dlp` available in PATH (optional — only for downloading online sources)
+- `ELEVENLABS_API_KEY` set in `.env` — required for transcript generation via ElevenLabs Scribe
+- `~/.claude/skills/video-use` symlink present — set up by `setup/install-skill.sh`
+- Commands run from an exported working directory; raw footage lives under `${VIDEO_USE_HOME}/<project>/`

package/assets/worker-kits/growthub-video-use-studio-v1/setup/check-deps.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+need_cmd() {
+  command -v "$1" >/dev/null 2>&1 || {
+    echo "Missing dependency: $1" >&2
+    exit 1
+  }
+}
+
+optional_cmd() {
+  if ! command -v "$1" >/dev/null 2>&1; then
+    echo "Optional dependency not found: $1 (only needed for downloading online sources)" >&2
+  fi
+}
+
+need_cmd python3
+need_cmd pip3
+need_cmd git
+need_cmd ffmpeg
+optional_cmd yt-dlp

package/assets/worker-kits/growthub-video-use-studio-v1/setup/clone-fork.sh

@@ -0,0 +1,18 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REPO_URL="${VIDEO_USE_REPO_URL:-https://github.com/browser-use/video-use}"
+# Canonical: VIDEO_USE_HOME. Legacy alias: VIDEO_USE_FORK_PATH.
+LOCAL_PATH="${VIDEO_USE_HOME:-${VIDEO_USE_FORK_PATH:-$HOME/video-use}}"
+
+if [ -d "${LOCAL_PATH}/.git" ]; then
+  git -C "${LOCAL_PATH}" fetch origin
+  git -C "${LOCAL_PATH}" pull --ff-only
+else
+  git clone "${REPO_URL}" "${LOCAL_PATH}"
+fi
+
+# Install the upstream package in editable mode so the CLI + skill resolve correctly.
+if command -v pip3 >/dev/null 2>&1; then
+  (cd "${LOCAL_PATH}" && pip3 install -e .)
+fi

package/assets/worker-kits/growthub-video-use-studio-v1/setup/install-skill.sh

@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Register the video-use fork as a Claude Code skill per the upstream README contract.
+# Canonical: VIDEO_USE_HOME. Legacy alias: VIDEO_USE_FORK_PATH.
+LOCAL_PATH="${VIDEO_USE_HOME:-${VIDEO_USE_FORK_PATH:-$HOME/video-use}}"
+SKILLS_DIR="${CLAUDE_SKILLS_DIR:-$HOME/.claude/skills}"
+LINK_PATH="${SKILLS_DIR}/video-use"
+
+if [ ! -d "${LOCAL_PATH}" ]; then
+  echo "video-use fork not found at ${LOCAL_PATH}. Run setup/clone-fork.sh first." >&2
+  exit 1
+fi
+
+mkdir -p "${SKILLS_DIR}"
+
+if [ -L "${LINK_PATH}" ] || [ -e "${LINK_PATH}" ]; then
+  echo "Skill entry already present at ${LINK_PATH}. Leaving as-is." >&2
+  exit 0
+fi
+
+ln -s "${LOCAL_PATH}" "${LINK_PATH}"
+echo "Linked ${LOCAL_PATH} -> ${LINK_PATH}"

package/assets/worker-kits/growthub-video-use-studio-v1/setup/verify-env.mjs

@@ -0,0 +1,23 @@
+import fs from "node:fs";
+import path from "node:path";
+
+const envPath = path.resolve(process.cwd(), ".env");
+if (!fs.existsSync(envPath)) {
+  console.error(".env not found. Run: cp .env.example .env");
+  process.exit(1);
+}
+
+const raw = fs.readFileSync(envPath, "utf8");
+
+// Canonical: VIDEO_USE_HOME. Legacy alias: VIDEO_USE_FORK_PATH.
+if (!raw.includes("VIDEO_USE_HOME=") && !raw.includes("VIDEO_USE_FORK_PATH=")) {
+  console.error("VIDEO_USE_HOME (or legacy VIDEO_USE_FORK_PATH) is required in .env");
+  process.exit(1);
+}
+
+if (!/ELEVENLABS_API_KEY=\S/.test(raw) || /ELEVENLABS_API_KEY=your_elevenlabs_key_here/.test(raw)) {
+  console.error("ELEVENLABS_API_KEY is required in .env (for ElevenLabs Scribe transcription)");
+  process.exit(1);
+}
+
+console.log("Environment check passed.");

package/assets/worker-kits/growthub-video-use-studio-v1/skills/README.md

@@ -0,0 +1,23 @@
+# `skills/` — nested sub-skill convention (primitive #5)
+
+A **sub-skill** is a full `SKILL.md`-addressable lane that a parent skill can spawn as a parallel sub-agent.
+
+## Convention
+
+```
+skills/
+├── README.md                        # this file
+└── <slug>/                          # kebab-case; matches the SKILL.md name
+    ├── SKILL.md                     # frontmatter + routing body (≤ 500 lines)
+    ├── references/                  # optional — long docs loaded on demand
+    ├── templates/                   # optional — reusable text/JS templates
+    └── scripts/                     # optional — deterministic helpers
+```
+
+Each sub-skill's frontmatter follows `@growthub/api-contract/skills::SkillManifest`. Sub-skills share the parent's `.growthub-fork/project.md` journal — they do not branch it.
+
+## Parallelism
+
+Spawn a sub-skill sub-agent when (a) the sub-skill's work is fully scoped by its own criteria, and (b) the parent's next step does not depend on intermediate state from the sub-skill. Each sub-skill run appends a row to `project.md::subSkillRuns` so the parent can read the outcome on return.
+
+See the parent `SKILL.md` `subSkills[]` array for the current roster.

package/assets/worker-kits/growthub-video-use-studio-v1/skills.md

@@ -0,0 +1,21 @@
+# Video Use Studio Skills
+
+1. Read `runtime-assumptions.md`.
+2. Read `docs/video-use-fork-integration.md`.
+3. Confirm target format: content type, target length, aesthetic direction.
+4. Produce, in order:
+   - `templates/video-brief.md` — source inventory, goal, audience, duration
+   - `templates/edit-strategy.md` — 4–8 sentence proposed approach, wait for confirmation
+   - `templates/edit-decision-list.md` — transcript-anchored EDL with word-boundary cuts
+   - `templates/render-plan.md` — FFmpeg commands, overlay tool choice (Manim / Remotion / PIL)
+   - `templates/qa-checklist.md` — twelve production rules pass, subtitles-last validation
+
+Non-negotiable rules enforced by this kit:
+
+- Subtitles are applied last, after all overlays.
+- 30 ms audio fades at every segment boundary.
+- Word-boundary snapping for every cut; never cut inside a word.
+- Overlays use `setpts=PTS-STARTPTS+T/TB` for timing.
+- Cached transcripts are reused; never re-transcribe a source twice.
+
+Use deterministic command paths. Resolve workspace with `${VIDEO_USE_HOME:-$HOME/video-use}`. Never expose `ELEVENLABS_API_KEY` in output artifacts.

package/assets/worker-kits/growthub-video-use-studio-v1/templates/edit-decision-list.md

@@ -0,0 +1,17 @@
+# Edit Decision List
+
+Every cut is snapped to a word boundary from the packed transcript. Timestamps are source-relative (HH:MM:SS.mmm). Never cut inside a word.
+
+| # | Source file | In (word-boundary) | Out (word-boundary) | Pad (ms) | Overlay | Notes |
+|---|---|---|---|---|---|---|
+|   |   |   |   |   |   |   |
+
+## Overlay references
+
+- Overlay tool (Manim / Remotion / PIL):
+- Timing shift formula: `setpts=PTS-STARTPTS+T/TB`
+
+## Caption strategy
+
+- Packed phrase-level transcript path:
+- Subtitles applied last, after all overlays.

package/assets/worker-kits/growthub-video-use-studio-v1/templates/edit-strategy.md

@@ -0,0 +1,11 @@
+# Edit Strategy
+
+4–8 sentences describing the proposed edit approach. The user must confirm this document in plain English before an EDL is generated.
+
+- Opening hook:
+- Core through-line:
+- Pacing bias (tight / breathing / mixed):
+- Aesthetic direction (grade, overlay tool, typography):
+- Captions strategy:
+- Target length + rationale:
+- Risks to surface during self-evaluation:

package/assets/worker-kits/growthub-video-use-studio-v1/templates/project.md

@@ -0,0 +1,48 @@
+---
+# .growthub-fork/project.md — session memory primitive (v1)
+#
+# Written by the CLI at init/import time. Append-only, human-readable; sits
+# alongside the machine-readable `trace.jsonl`. Approvals, self-eval outcomes,
+# and sub-skill runs all record here.
+#
+# Replaceable tokens (seeded at init time):
+#   {{KIT_ID}}   {{FORK_ID}}   {{STARTED_AT}}   {{SOURCE}}   {{SOURCE_REF}}
+
+kitId: "{{KIT_ID}}"
+forkId: "{{FORK_ID}}"
+startedAt: "{{STARTED_AT}}"
+source: "{{SOURCE}}"
+sourceRef: "{{SOURCE_REF}}"
+skillManifestVersion: 1
+approvals: []
+selfEvalHistory: []
+subSkillRuns: []
+---
+
+# Project journal — fork `{{FORK_ID}}`
+
+Baseline primitive: `{{KIT_ID}}`. Seeded at `{{STARTED_AT}}` from `{{SOURCE}}` (`{{SOURCE_REF}}`).
+
+This is your cross-session continuity surface. Read the last few entries before every session; append after every material change, approval, and self-eval boundary.
+
+## How to use this file
+
+1. **Session start.** Read the last 3 entries + tail 20 events in `.growthub-fork/trace.jsonl`. State your plan.
+2. **Material change.** Record as a dated bullet (what, why, outcome). Simultaneously append a typed event to `trace.jsonl` via the Fork Sync Agent — never bypass.
+3. **Approval boundary.** Add a row to `approvals` in the frontmatter (verbatim decision).
+4. **Self-eval boundary.** Append to `selfEvalHistory`: `attempt`, `criteria`, `outcome`, `notes`. Enforce `maxRetries: 3`.
+5. **Sub-skill spawn.** Append to `subSkillRuns`: `subSkill`, `startedAt`, `result`.
+
+## Session log
+
+<!-- Append newest entries at the bottom. Format:
+
+### {{YYYY-MM-DD HH:mm UTC}} · {{skill-slug}}
+- **Plan.** What you intend to do.
+- **Changes.** Material changes (each must correspond to a trace event).
+- **Outcome.** Pass / fail / parked. Reference self-eval criteria.
+- **Next.** What the next session should pick up.
+
+-->
+
+_No sessions recorded yet. Populated as the fork is operated._

package/assets/worker-kits/growthub-video-use-studio-v1/templates/qa-checklist.md

@@ -0,0 +1,21 @@
+# QA Checklist — Twelve Production Rules
+
+- [ ] Subtitles applied last, after every overlay
+- [ ] 30 ms audio fade at every segment boundary
+- [ ] Overlays shifted with `setpts=PTS-STARTPTS+T/TB`
+- [ ] Every cut snapped to a word boundary
+- [ ] Cut edges padded 30–200 ms
+- [ ] No cut inside a word
+- [ ] No re-transcription of a cached source
+- [ ] Caption alignment matches the packed phrase-level transcript
+- [ ] 30 ms fade-out on every overlay exit
+- [ ] Subtitle sequencing respects speaker turns
+- [ ] Output validated (duration, codec, resolution) before handoff
+- [ ] Every destructive edit decision appended to `project.md`
+
+## Delivery checks
+
+- [ ] Duration matches brief (± 500 ms)
+- [ ] Aspect ratio correct
+- [ ] Audio sync verified
+- [ ] `${VIDEO_USE_HOME}/<project>/edit/final.mp4` exists and plays end-to-end

package/assets/worker-kits/growthub-video-use-studio-v1/templates/render-plan.md

@@ -0,0 +1,40 @@
+# Render Plan
+
+## Source resolution
+
+```bash
+WORKSPACE="${VIDEO_USE_HOME:-${VIDEO_USE_FORK_PATH:-$HOME/video-use}}"
+PROJECT_DIR="${WORKSPACE}/<project>"
+```
+
+## Transcription (idempotent — never re-transcribe a cached source)
+
+```bash
+cd "${PROJECT_DIR}"
+# ElevenLabs Scribe, keyed by ELEVENLABS_API_KEY from .env
+python -m video_use.transcribe --source <input.mp4>
+```
+
+## Render
+
+```bash
+cd "${PROJECT_DIR}"
+python -m video_use.render \
+  --edl ../output/<client-slug>/<project-slug>/edit-decision-list.md \
+  --overlay <manim|remotion|pil> \
+  --out edit/final.mp4
+```
+
+## FFmpeg hard constraints
+
+- 30 ms audio fade at every segment boundary.
+- Word-boundary snapping for all cuts; pad edges 30–200 ms.
+- Overlays shifted with `setpts=PTS-STARTPTS+T/TB`.
+- Subtitles are applied last.
+
+## Checks
+
+- Output path: `${PROJECT_DIR}/edit/final.mp4`
+- Duration matches brief (± 500 ms)
+- Codec: h264, audio: aac
+- Self-evaluation loop runs up to 3 times before surfacing output

package/assets/worker-kits/growthub-video-use-studio-v1/templates/self-eval.md

@@ -0,0 +1,67 @@
+# Self-evaluation template — v1 primitive (Growthub, capability-agnostic)
+
+A skill's `selfEval` contract declares **what good looks like** (`criteria[]`) and **the retry ceiling** (`maxRetries`). The agent drives the loop; this file is the pattern the agent follows at every unit of work.
+
+The contract is defined in `@growthub/api-contract/skills::SkillSelfEval` and is **capability-agnostic** — the same primitive applies to code edits, copy drafts, CRM rules, API payloads, asset renders, audit passes, and every other domain. The "unit of work" is the smallest reversible change the skill operates on; concrete boundaries are defined in the kit's own `skills.md` operator runbook, not here.
+
+## Loop
+
+```
+for attempt in 1..maxRetries:          # default maxRetries = 3
+  generate       — produce a proposal (whatever the skill produces)
+  apply          — materialise the proposal against the fork
+  self-evaluate  — for each criterion in skill.selfEval.criteria:
+                     check → pass / fail / needs-confirmation
+  record         — append to project.md (human) + trace.jsonl (machine)
+
+  if all criteria pass: break
+  if attempt == maxRetries: park with needs_confirmation note. Stop.
+```
+
+## What each attempt writes
+
+### Human row — append to `.growthub-fork/project.md` "Session log"
+
+```md
+### 2026-04-23 18:40 UTC · <skill-slug>
+- **Plan.** What you intend to do this unit of work.
+- **Changes.** Material change applied (must correspond to a trace event).
+- **Self-eval.** attempt 2/3 — criterion "<one of skill.selfEval.criteria>" ✗ (<note>). Retrying.
+- **Outcome.** retry-pending / pass / parked.
+- **Next.** What the next attempt (or next session) should pick up.
+```
+
+### Machine row — append to `.growthub-fork/trace.jsonl` (via `appendKitForkTraceEvent`)
+
+```json
+{
+  "ts": "2026-04-23T18:40:00.000Z",
+  "forkId": "<fork-id>",
+  "kitId": "<kit-id>",
+  "type": "self_eval_recorded",
+  "summary": "attempt 2/3 failed on <criterion>",
+  "detail": {
+    "skill": "<skill-slug>",
+    "attempt": 2,
+    "maxRetries": 3,
+    "criterion": "<one of skill.selfEval.criteria>",
+    "outcome": "fail",
+    "notes": "<short explanation>"
+  }
+}
+```
+
+## Hard rules
+
+1. **Never exceed `maxRetries`.** At the ceiling, park with a `needs_confirmation` note and stop. Do not loop forever.
+2. **Record every attempt.** Even the first pass. Continuity depends on a complete journal.
+3. **Keep `project.md` and `trace.jsonl` in sync.** One without the other is a protocol violation.
+4. **Preserve prior entries.** Append-only. Never rewrite history.
+
+## Bound the blast radius
+
+Evaluate at the smallest unit of work the skill operates on, not only at the end of a multi-step run. The retry ceiling applies to that unit — so a bad attempt does not sink the whole job.
+
+What counts as a "unit of work" is **kit-specific** and lives in that kit's `skills.md` operator runbook — not in this agnostic template. A kit picks its own smallest reversible boundary and documents it in `skills.md`; this template does not prescribe one.
+
+The agnostic SDK (`@growthub/api-contract/skills::SkillSelfEval`) does not encode any domain-specific boundaries — it only carries `criteria[]`, `maxRetries`, and `traceTo`. See `SKILL.md::selfEval.criteria` in this kit for the concrete checks, and `skills.md` for the kit-specific unit of work.

package/assets/worker-kits/growthub-video-use-studio-v1/templates/video-brief.md

@@ -0,0 +1,11 @@
+# Video Brief
+
+- Goal:
+- Audience:
+- Source footage directory (`${VIDEO_USE_HOME}/<project>/`):
+- Duration target:
+- Aspect ratio:
+- Delivery format: MP4 (h264)
+- Aesthetic direction:
+- Speakers / on-camera subjects:
+- External sources to pull via `yt-dlp` (optional):

package/assets/worker-kits/growthub-video-use-studio-v1/validation-checklist.md

@@ -0,0 +1,11 @@
+# Validation Checklist
+
+- [ ] `bash setup/check-deps.sh` — Python, pip, git, ffmpeg present
+- [ ] `node setup/verify-env.mjs` — `VIDEO_USE_HOME` and `ELEVENLABS_API_KEY` set
+- [ ] `bash setup/clone-fork.sh` — video-use cloned and `pip install -e .` succeeded
+- [ ] `bash setup/install-skill.sh` — `~/.claude/skills/video-use` symlink in place
+- [ ] Source footage staged under `${VIDEO_USE_HOME}/<project>/`
+- [ ] Planning artifacts written to `output/<client-slug>/<project-slug>/`
+- [ ] `edit-strategy.md` confirmed before EDL generation
+- [ ] Twelve production rules checklist passes in `qa-checklist.md`
+- [ ] Final render exists at `${VIDEO_USE_HOME}/<project>/edit/final.mp4`

package/assets/worker-kits/growthub-video-use-studio-v1/workers/video-use-studio-operator/CLAUDE.md

@@ -0,0 +1,93 @@
+# Video Use Studio Operator
+
+**Kit:** `growthub-video-use-studio-v1`  
+**Worker ID:** `video-use-studio-operator`  
+**Version:** `1.0.0`
+
+## Role
+
+You convert raw footage and edit intent into implementation-ready video-use artifacts: a brief, a confirmed edit strategy, a transcript-anchored EDL, a render plan, and a QA pass. You operate the upstream [browser-use/video-use](https://github.com/browser-use/video-use) pipeline (transcription → packing → LLM reasoning → EDL → render → self-eval) from an exported working directory.
+
+## Required startup
+
+1. Read `skills.md`.
+2. Read `runtime-assumptions.md`.
+3. Read `docs/video-use-fork-integration.md`.
+4. Resolve `WORKSPACE="${VIDEO_USE_HOME:-${VIDEO_USE_FORK_PATH:-$HOME/video-use}}"`.
+5. Verify environment with `node setup/verify-env.mjs`.
+
+If setup checks fail, stop and return remediation only. Do not invent API keys or hardcode machine paths.
+
+## Input contract
+
+- Raw footage already staged under `${VIDEO_USE_HOME}/<project>/`.
+- Brand kit at `brands/<client>/brand-kit.md` (copied from `brands/_template/`).
+- User-supplied goal, target length, aesthetic direction.
+
+## Output artifacts
+
+Write every planning deliverable to `output/<client-slug>/<project-slug>/`:
+
+- `video-brief.md` — goal, audience, duration, ratio, delivery format
+- `edit-strategy.md` — 4–8 sentence proposed approach, wait for explicit user confirmation before proceeding
+- `edit-decision-list.md` — transcript-anchored cut list with word-boundary timestamps and overlay markers
+- `render-plan.md` — FFmpeg filter graph, overlay tool choice, caption sequencing
+- `qa-checklist.md` — twelve production rules pass
+
+Rendered output is the upstream pipeline's responsibility:
+
+- `${VIDEO_USE_HOME}/<project>/edit/final.mp4`
+
+## Fork integration
+
+- Upstream contract: conversational edits via Claude Code skill at `~/.claude/skills/video-use`.
+- Transcription: ElevenLabs Scribe (word-level, speaker-tagged, audio-event markers).
+- Overlays: Manim / Remotion / PIL — operator chooses per project aesthetic.
+- Session persistence: append each decision to `project.md` inside the source video directory.
+- Self-evaluation loop: up to three iterative fixes before surfacing output to the user.
+
+## Non-negotiable production rules
+
+1. Subtitles last — applied after every overlay.
+2. 30 ms audio fade at every segment boundary.
+3. Overlays shifted with `setpts=PTS-STARTPTS+T/TB`.
+4. Word-boundary snapping for every cut.
+5. Pad cut edges with a 30–200 ms working window.
+6. Never cut inside a word.
+7. Never re-transcribe a cached source.
+8. Caption alignment matches the packed phrase-level transcript.
+9. 30 ms fade-out on every overlay exit.
+10. Subtitle sequencing respects speaker turns.
+11. Output is validated (duration, codec, resolution) before user handoff.
+12. Every destructive edit decision is logged to `project.md`.
+
+## Troubleshooting
+
+- Missing `ELEVENLABS_API_KEY` → re-run `node setup/verify-env.mjs`.
+- CORS / network failures on transcription → check the ElevenLabs key is active.
+- `~/.claude/skills/video-use` missing → re-run `bash setup/install-skill.sh`.
+- `ffmpeg`/`yt-dlp` not found → re-run `bash setup/check-deps.sh`.
+
+Never write `.env` secrets into any output artifact. Never hardcode absolute user paths; always resolve through `${VIDEO_USE_HOME}` with a `$HOME/video-use` fallback.
+
+---
+
+## Governed-workspace primitives (v1.2)
+
+This workspace carries the six architectural primitives every Growthub fork inherits. The contract is capability-agnostic (`@growthub/api-contract/skills::SkillManifest`); kit-specific specialisation lives in `skills.md` above.
+
+1. **`SKILL.md`** at the kit root — the discovery entry / routing menu. Read before `skills.md`.
+2. **Repo-root `AGENTS.md` pointer** — Cursor / Claude / Codex all read the same contract.
+3. **`.growthub-fork/project.md`** — session memory, seeded at init/import from `templates/project.md`. Append a dated entry after every material change.
+4. **Self-evaluation (`selfEval.criteria` + `maxRetries`)** — generate → apply → evaluate → record; retry up to 3; every attempt writes to both `project.md` (human) and `trace.jsonl` (machine). Use `recordSelfEval` (`cli/src/skills/self-eval.ts`); never bypass the fork-trace primitive.
+5. **Nested `skills/<slug>/SKILL.md`** — sub-skill lanes for parallel sub-agents on heavy or narrow work.
+6. **`helpers/<verb>.{sh,mjs,py}`** — safe shell tool layer; promote any inline shell that gets used twice.
+
+Command surface from inside this fork:
+
+- `growthub skills list` — enumerate this fork’s SKILL.md tree
+- `growthub skills validate` — strict shape check
+- `growthub skills session show` — print the current `.growthub-fork/project.md`
+- `growthub skills session init --kit <kit-id>` — (re-)seed session memory
+
+Full user-facing narrative: `cli/assets/worker-kits/growthub-custom-workspace-starter-v1/docs/governed-workspace-primitives.md` (also shipped into any workspace forked from the starter kit).

package/assets/worker-kits/growthub-zernio-social-v1/SKILL.md

@@ -0,0 +1,90 @@
+---
+name: growthub-zernio-social-v1
+description: "Self-contained workspace for Zernio — the unified social media REST API for developers and AI agents. Use when the user says: \"zernio\", \"unified social api\", \"agent social posting\". Session memory tracks API calls, platform-specific payloads, and self-eval outcomes per post."
+triggers:
+  - zernio social
+  - zernio social media studio
+  - fork growthub-zernio-social-v1
+progressiveDisclosure: true
+sessionMemory:
+  path: .growthub-fork/project.md
+selfEval:
+  criteria:
+    - Operator contract (workers/zernio-social-operator/CLAUDE.md) read before any material change.
+    - .growthub-fork/project.md appended to at each material change.
+    - .growthub-fork/trace.jsonl receives a typed event for each material change.
+    - Kit-specific QUICKSTART / runtime-assumptions / output-standards honoured.
+  maxRetries: 3
+  traceTo: .growthub-fork/trace.jsonl
+helpers: []
+subSkills: []
+mcpTools: []
+---
+
+# Growthub Agent Worker Kit — Zernio Social Media Studio
+
+Discovery entry + routing menu for the `growthub-zernio-social-v1` worker kit. Family: `studio`. Agent contract: `workers/zernio-social-operator/CLAUDE.md`.
+
+## When to use this skill
+
+When the user's intent matches any of the triggers above — or when an agent has been dropped into a fork whose `.growthub-fork/fork.json` declares `kitId: "growthub-zernio-social-v1"`.
+
+## Decision tree
+
+```
+Fork exists (this directory contains .growthub-fork/fork.json)?
+├── No  → run: growthub starter init --out <path>   (or import-repo / import-skill)
+│         then: growthub kit download growthub-zernio-social-v1 --out <path>
+│
+└── Yes → read in this order:
+          1. .growthub-fork/project.md                         — session memory (primitive #3)
+          2. SKILL.md  (this file)                             — routing menu  (primitive #1)
+          3. skills.md                                         — operator runbook
+          4. workers/zernio-social-operator/CLAUDE.md                              — agent contract
+          5. QUICKSTART.md                                     — first-run steps
+          6. runtime-assumptions.md                            — host expectations
+          7. .growthub-fork/policy.json                        — what you may touch
+          8. .growthub-fork/trace.jsonl (tail 20)              — recent machine history
+```
+
+## The six primitives (same shape across every Growthub worker kit)
+
+1. **`SKILL.md`** — this file.
+2. **Symlinked pointer** — repo-root `AGENTS.md` is authoritative.
+3. **`.growthub-fork/project.md`** — session memory, seeded by the CLI from `templates/project.md` at init/import time.
+4. **Self-evaluation** — generate → apply → evaluate → record; retry up to `selfEval.maxRetries` (default 3); mirrors the Fork Sync Agent's preview → apply → trace loop (primitive #4). Contract: `@growthub/api-contract/skills::SkillSelfEval`.
+5. **`skills/`** — nested sub-skills for parallel sub-agents on heavy / narrow work.
+6. **`helpers/`** — safe shell tool layer. Promote inline shell here whenever the same snippet is re-used.
+
+## Self-evaluation (primitive #4)
+
+Enforce `selfEval.maxRetries: 3`. At the ceiling, park with a `needs_confirmation` note in `project.md` and stop. Record every attempt to both `project.md` and `trace.jsonl`.
+
+## Session memory (primitive #3)
+
+`.growthub-fork/project.md` is the only cross-session continuity surface for this fork. Append at every material change, approval boundary, and self-eval outcome.
+
+## Sub-skills (primitive #5)
+
+(None declared at the baseline; populate `skills/` and the frontmatter `subSkills[]` array as specialist lanes emerge.)
+
+## Helpers (primitive #6)
+
+(None declared at the baseline; populate `helpers/` and the frontmatter `helpers[]` array as inline shell matures.)
+
+## MCP routing (optional)
+
+List concrete MCP tool IDs in `mcpTools[]` when a fork runs an MCP server for auth-heavy actions. Declarative only at v1.
+
+## Related files
+
+- `skills.md` — operator runbook (deep)
+- `QUICKSTART.md` — first-run steps
+- `runtime-assumptions.md` — host expectations
+- `output-standards.md` — output locations + manifest shape
+- `validation-checklist.md` — pre-flight checklist (if present)
+- `templates/project.md` — session-memory template
+- `templates/self-eval.md` — self-evaluation template
+- `helpers/README.md` — safe shell tool layer convention
+- `skills/README.md` — sub-skill convention
+- `workers/zernio-social-operator/CLAUDE.md` — agent contract

package/assets/worker-kits/growthub-zernio-social-v1/bundles/growthub-zernio-social-v1.json

@@ -73,12 +73,19 @@
     "studio/src/views/Sequences.jsx",
     "studio/src/views/Templates.jsx",
     "growthub-meta/README.md",
-    "growthub-meta/kit-standard.md"
+    "growthub-meta/kit-standard.md",
+    "SKILL.md",
+    "templates/project.md",
+    "templates/self-eval.md",
+    "helpers/README.md",
+    "skills/README.md"
   ],
   "optionalPresets": [],
   "export": {
     "folderName": "growthub-agent-worker-kit-zernio-social-v1",
     "zipFileName": "growthub-agent-worker-kit-zernio-social-v1.zip"
   },
-  "activationModes": ["export"]
+  "activationModes": [
+    "export"
+  ]
 }

package/assets/worker-kits/growthub-zernio-social-v1/helpers/README.md

@@ -0,0 +1,29 @@
+# `helpers/` — safe shell tool layer (primitive #6)
+
+A **helper** is a small, deterministic script an agent invokes via one shell call instead of reconstructing a raw pipeline inline. Helpers are reviewable, deterministic, and safer than raw commands.
+
+## Convention
+
+```
+helpers/
+├── README.md                 # this file
+├── <verb>.sh                 # single-purpose shell scripts
+├── <verb>.mjs                # optional: Node-based helper
+└── <verb>.py                 # optional: Python-based helper
+```
+
+Every helper:
+
+1. Carries a one-line header comment: what it does + how to invoke it.
+2. Uses `set -euo pipefail` (or equivalent) — no silent failures.
+3. Has a matching row in the parent `SKILL.md`'s `helpers[]` frontmatter.
+4. Is referenced from `skills.md` at the step the agent should invoke it (no duplicated shell bodies).
+
+## When to promote an inline snippet
+
+- Appears more than once in `skills.md`.
+- Has fragile quoting or path interpolation.
+- Calls a side-effecting binary (ffmpeg, git, gh, npm install).
+- Multiple sub-skills invoke it.
+
+See the parent `SKILL.md` `helpers[]` array for the current roster.

package/assets/worker-kits/growthub-zernio-social-v1/kit.json

@@ -85,7 +85,12 @@
     "studio/src/views/Sequences.jsx",
     "studio/src/views/Templates.jsx",
     "growthub-meta/README.md",
-    "growthub-meta/kit-standard.md"
+    "growthub-meta/kit-standard.md",
+    "SKILL.md",
+    "templates/project.md",
+    "templates/self-eval.md",
+    "helpers/README.md",
+    "skills/README.md"
   ],
   "setupPaths": {
     "quickstart": "QUICKSTART.md",
@@ -112,7 +117,14 @@
       "studio/dist",
       "templates",
       "docs",
-      "growthub-meta"
+      "growthub-meta",
+      "SKILL.md",
+      "templates/project.md",
+      "templates/self-eval.md",
+      "helpers",
+      "helpers/README.md",
+      "skills",
+      "skills/README.md"
     ]
   },
   "bundles": [