opencode-skills-collection 4.0.66 → 4.0.68

package/bundled-skills/beatra-ai-video-studio/SKILL.md

@@ -0,0 +1,272 @@
+---
+name: beatra-ai-video-studio
+description: "Install and use the official Beatra AI Video Studio package, pinned by digest, for paid text-to-video, image-to-video, and video edit or extend jobs on the hosted Beatra service."
+category: media
+risk: critical
+source: community
+source_repo: beatra-ai/beatra-skills
+source_type: official
+date_added: "2026-09-17"
+author: beatra-ai
+tags: [video-generation, text-to-video, image-to-video, video-editing, mcp, paid-api, beatra]
+tools: [claude, codex, cursor, gemini]
+license: "MIT-0"
+license_source: "https://github.com/beatra-ai/beatra-skills/blob/95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d/LICENSE"
+---
+
+# Beatra AI Video Studio
+
+## Overview
+
+Beatra AI Video Studio is Beatra's official agent package for short AI video
+work: text-to-video, image-to-video, first/last-frame interpolation,
+reference-guided generation, and editing or extending an existing clip. The
+video is produced on the hosted, paid Beatra service (`mcp.beatra.ai`).
+
+This catalog entry is a **reviewed pointer, not the executable package**. It
+contains no client code and performs no Beatra operation by itself. The package
+it points to bundles three standard-library Python scripts that make network
+calls, store a credential, and can replace their own files. Read
+[Install](#install-pinned-verified-approved-twice) and
+[Security & Safety Notes](#security--safety-notes) before activating it.
+
+| Pinned identity | Value |
+| --- | --- |
+| Package | `beatra-ai-video-studio` `1.2.5` |
+| Archive | `https://cdn.beatra.ai/agent-packages/beatra-ai-video-studio/v1.2.5/beatra-ai-video-studio-skill-1.2.5.zip` |
+| Archive SHA-256 | `679a3ddc06c7be631ef31f002f918465a26f17a189ffac723f45dfd348e1fc4a` |
+| Source tree | [`beatra-ai/beatra-skills@95d662f`](https://github.com/beatra-ai/beatra-skills/tree/95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d/skills/beatra-ai-video-studio) (full SHA `95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d`) |
+| License | MIT No Attribution (MIT-0) |
+
+The archive holds 17 regular files (no symlinks, no executable bits, no
+binaries), and every file is byte-identical to the source tree at that commit.
+
+## When to Use This Skill
+
+- Use when the user explicitly wants a short AI video clip produced on Beatra
+  and accepts that the work is paid and runs on a hosted service.
+- Use when a still image should be animated, two frames interpolated, or an
+  existing clip edited or extended by Beatra.
+- Do not use for local-only or offline video editing, timeline assembly, or
+  when the user has not agreed to send prompts and media to a third party.
+
+## Install (pinned, verified, approved twice)
+
+### Step 1: Download and verify into a review directory
+
+Explain that this downloads an external package from `cdn.beatra.ai`, then ask
+for approval. Only after approval:
+
+```bash
+umask 077
+review_dir="$(mktemp -d)"
+cd "$review_dir" || exit 1
+curl -fsSLO "https://cdn.beatra.ai/agent-packages/beatra-ai-video-studio/v1.2.5/beatra-ai-video-studio-skill-1.2.5.zip"
+printf '%s  %s\n' \
+  '679a3ddc06c7be631ef31f002f918465a26f17a189ffac723f45dfd348e1fc4a' \
+  'beatra-ai-video-studio-skill-1.2.5.zip' | shasum -a 256 -c -
+```
+
+Stop if the check does not print `OK`. The expected digest comes from this
+catalog entry, not from a file on the same CDN.
+
+### Step 2: Inspect before activation
+
+```bash
+unzip -l beatra-ai-video-studio-skill-1.2.5.zip
+unzip -q beatra-ai-video-studio-skill-1.2.5.zip
+find beatra-ai-video-studio -type l -print            # expect no output
+find beatra-ai-video-studio -type f -perm -111 -print # expect no output
+grep -n '"auto_update": True' beatra-ai-video-studio/scripts/mcp_client.py
+```
+
+Optionally confirm byte identity with the public source tree (a second,
+independent host):
+
+```bash
+git clone --quiet --filter=blob:none --no-checkout https://github.com/beatra-ai/beatra-skills.git src
+git -C src checkout --quiet 95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d -- skills/beatra-ai-video-studio
+(cd beatra-ai-video-studio && find . -type f | LC_ALL=C sort | xargs shasum -a 256) > archive.sha
+(cd src/skills/beatra-ai-video-studio && find . -type f | LC_ALL=C sort | xargs shasum -a 256) > tree.sha
+cmp archive.sha tree.sha && echo IDENTICAL
+```
+
+Report to the user what the review found: `SKILL.md`, `manifest.json`, 12
+Markdown references, and `scripts/authorize.py`, `scripts/mcp_client.py`,
+`scripts/uninstall.py` (Python 3.10+, standard library only, no dependency
+installation, no lifecycle hooks). Summarize the network, credential,
+local-state, telemetry, and self-update behavior listed under
+[Security & Safety Notes](#security--safety-notes).
+
+### Step 3: Copy in and disable self-update before any other command
+
+Ask for a **second, separate** approval, because this changes agent
+configuration. Then copy the reviewed tree to the host's skills directory
+(Claude Code shown; use the equivalent path for other hosts) and immediately
+turn off silent self-update for that exact path:
+
+```bash
+dest="$HOME/.claude/skills/beatra-ai-video-studio"
+test ! -e "$dest" || { echo "destination exists; stop and ask the user"; exit 1; }
+cp -R beatra-ai-video-studio "$dest"
+python3 "$dest/scripts/mcp_client.py" update --auto off
+```
+
+The last command must print
+`Automatic Beatra package updates are disabled.` It writes only
+`~/.beatra/updates/<id>/state.json` and makes no network request. Run it
+before `authorize.py`, `verify`, `tools`, `upload`, or `call`: in version 1.2.5
+self-update is **on by default** (see below). The setting is keyed to the
+resolved install path, so repeat it after moving or re-copying the directory.
+
+### Step 4: Authorize as its own decision
+
+Authorization opens a browser sign-in and stores a bearer token. Ask first.
+
+```bash
+python3 "$dest/scripts/authorize.py"
+```
+
+Start a new agent session if the host discovers skills only at startup.
+
+## How It Works
+
+1. Read the installed package's `SKILL.md` and its references; they define the
+   video routes, payload shapes, and review loop.
+2. Use free, non-billable discovery first (`beatra.models.list`, task list) to
+   read current model cards, durations, resolutions, and credit estimates.
+3. Show the user a cost card for exactly one paid call: tool, model, duration,
+   resolution, estimate, and which files will be uploaded. Wait for explicit
+   approval. Planning or "make the clip" is not approval.
+4. Upload only files the user supplied and approved for this task, then submit
+   once with a stable `client_request_id` and poll the returned task.
+5. Report the delivered artifact and `billing.net_charged_credits`, review the
+   clip with the user, and ask again before any further paid stage.
+
+## Examples
+
+### Free connection check (non-billable)
+
+```bash
+python3 "$HOME/.claude/skills/beatra-ai-video-studio/scripts/mcp_client.py" verify
+```
+
+### One approved text-to-video call
+
+After the user approved the cost card for this exact payload:
+
+```bash
+printf '%s' '{"prompt":"A close product reveal with one slow push-in.","model":"auto","duration":5,"client_request_id":"req-7f3c2a"}' \
+  | python3 "$HOME/.claude/skills/beatra-ai-video-studio/scripts/mcp_client.py" call beatra.videos.generate
+```
+
+If the response is lost, retry only with the same `client_request_id` and
+identical arguments; never submit a replacement while the task is running.
+
+## Update
+
+This entry does not endorse the package's silent self-update. Keep
+`update --auto off` in place and do not run `update --auto on` or a bare
+`update` without explicit approval.
+
+To move to a newer version, repeat Steps 1 to 3 for that version in a new
+review directory, verify its digest against the matching tree in
+`beatra-ai/beatra-skills` (a version not listed in this entry has not been
+reviewed here), show the user the file-level changes against the installed
+copy, and replace the directory only after approval. `update --check` reports
+the available version from `beatra.ai` without changing files.
+
+## Uninstall
+
+```bash
+dest="$HOME/.claude/skills/beatra-ai-video-studio"
+python3 "$dest/scripts/uninstall.py" --dry-run
+python3 "$dest/scripts/uninstall.py"
+```
+
+Read the JSON decision. `disconnected` means this was the last Beatra skill on
+the device: the token was revoked (when `revoked` is `true`) and the files
+`credentials.json`, `installation.json`, `host.json`, `skills.json`, and
+`registrations.json` under `~/.beatra` were removed. `keep_connection` means
+another Beatra skill still uses the shared token, which stays. Then, after
+confirming the path with the user, delete `$dest`.
+
+`uninstall.py` does not remove `~/.beatra/updates/`. When the decision is
+`disconnected` and no other Beatra skill is installed, remove that directory
+too; otherwise leave it. A token that could not be revoked expires after 15
+days idle and can be revoked at once in the Beatra Console under Agents.
+
+## Best Practices
+
+- ✅ Keep one approval per paid call, per upload set, and per install step.
+- ✅ Start with the shortest duration and lowest resolution the model admits.
+- ✅ Report net charged credits from the terminal task, not the estimate.
+- ❌ Do not re-enable self-update or install an unreviewed version silently.
+- ❌ Do not print, paste, or move the token out of `~/.beatra/credentials.json`.
+- ❌ Do not retry a paid call with a new request ID after an uncertain response.
+
+## Limitations
+
+- Requires a Beatra account, network access, Python 3.10+, and prepaid credits;
+  the sign-up gift usually cannot cover a video generation.
+- Short clips only; not a timeline editor. Multi-shot work is delivered as
+  separate clips.
+- Generation is asynchronous and can take minutes. Upload size is capped at
+  100 MB and a model may impose a lower limit.
+- Models, prices, schemas, and availability are controlled by Beatra and its
+  upstream model providers and can change; the service is provided as is.
+- Outputs are probabilistic, not guaranteed unique or non-infringing, and need
+  human review before publication.
+
+## Security & Safety Notes
+
+`risk: critical` is deliberate.
+
+- **Network.** Authorization uses `api.beatra.ai`; every tool call and upload
+  goes to `mcp.beatra.ai`. With self-update left on, the client also fetches
+  `https://beatra.ai/skills/beatra-ai-video-studio/install.json` and archives
+  from `cdn.beatra.ai`.
+- **Self-update (on by default in 1.2.5).** Before `verify`, `tools`, `upload`,
+  or `call`, the client checks for a newer release at most once every 24 hours
+  and, if one exists, replaces package-owned files without per-update preview
+  or approval. It pins host and path, verifies checksums from Beatra's own
+  discovery document and CDN, and rolls back on failure, but those digests are
+  not independently anchored. This entry therefore requires
+  `update --auto off` before first use, as in Step 3.
+- **Uploads and third parties.** Prompts and uploaded media are sent to Beatra
+  and forwarded to the third-party model provider executing the task. Beatra
+  is hosted outside mainland China. See the
+  [privacy policy](https://beatra.ai/en/privacy).
+- **Billing.** Paid tools consume prepaid credits. Credits for tasks that fail
+  for reasons attributable to Beatra or the upstream model are returned
+  automatically; otherwise purchases are non-refundable, and actual usage can
+  exceed the estimate and leave a negative balance. See the
+  [terms](https://beatra.ai/en/terms).
+- **Credentials.** `authorize.py` runs an OAuth device flow, opens the browser,
+  and stores one bearer token in `~/.beatra/credentials.json` (directory
+  `0700`, file `0600`). The token never goes into argv, environment variables,
+  or output. It carries full Beatra scope, including `wallet:spend`, has a
+  sliding 15-day idle lifetime, and is shared by every Beatra skill on the
+  device.
+- **Local state.** `~/.beatra/` also holds `installation.json` (random
+  installation reference), `host.json` (agent platform and hostname),
+  `skills.json` (installed Beatra skill paths), `registrations.json`, and
+  `updates/<id>/state.json` plus update backups when updates run.
+- **Telemetry.** The device flow sends the hostname as the device name, the
+  package slug and version, and the detected agent platform (for example
+  `claude-code`, from environment variables). On first use the client makes a
+  non-billable `beatra.installations.register` call, and every tool call adds
+  `source_package_slug` and `source_platform`. There is no opt-out for these
+  fields.
+- **Retention.** Account data is kept for the life of the account. Task
+  records, artifacts, and billing ledgers are retained after account closure
+  for audit and tax purposes.
+- **Content rights.** Users keep rights in their inputs and receive Beatra's
+  rights in outputs; they must hold rights to uploaded media and must not
+  create deceptive impersonations.
+
+## Additional Resources
+
+- [Source tree at the pinned commit](https://github.com/beatra-ai/beatra-skills/tree/95d662f7aeddd6e2aa6da9e14f9c985e3f6b914d/skills/beatra-ai-video-studio)
+- [Product page](https://beatra.ai/skills/beatra-ai-video-studio)
+- [Terms](https://beatra.ai/en/terms) and [privacy policy](https://beatra.ai/en/privacy)

package/bundled-skills/google-no-code/SKILL.md

@@ -0,0 +1,136 @@
+---
+name: google-no-code
+description: "Design Google Forms and wire Apps Script triggers (onFormSubmit) for email alerts, spreadsheet logging, and dynamic questions — no code editor required."
+category: automation
+risk: safe
+source: self
+source_type: self
+date_added: "2026-09-19"
+author: WHOISABHISHEKADHIKARI
+tags: [google, forms, apps-script]
+tools: [claude, cursor, gemini]
+---
+
+# Google No-Code Forms Automation
+
+## Overview
+
+Guides the user through building a Google Form in the Forms UI and connecting it to Google Apps Script triggers, without writing a custom integration or leaving the browser. Covers form design, the Apps Script editor, the `onFormSubmit` trigger, and small response-handling scripts that run automatically when a form is submitted.
+
+## When to Use This Skill
+
+- Use when the user wants to build a Google Form and automate what happens after submissions.
+- Use when the user asks for email alerts, spreadsheet logging, or conditional handling of form responses.
+- Use when the user wants Apps Script snippets to paste into a form bound script project.
+- Skip this skill if the user needs custom UI, paid APIs, or a full standalone Apps Script application.
+
+## How It Works
+
+### Step 1: Define the form in the Forms UI
+
+Create the form in Google Forms with clear questions, answer types (short answer, multiple choice, checkbox), and required fields. Match question IDs to what the script will need later. Add a description to the form so respondents know what to expect.
+
+### Step 2: Open the bound Apps Script editor
+
+In the form, go to `Extensions > Apps Script`. This opens a project bound to the form. The script can read each submission through the `e.response` event object.
+
+### Step 3: Write the response handler
+
+Add a function that accepts the `onFormSubmit` event, reads `e.response` with `getItemResponses()`, and then performs the desired action: send an email, write to a spreadsheet, or branch on answers.
+
+### Step 4: Install the trigger
+
+In Apps Script, go to the clock/triggers menu, select the `onFormSubmit` function, choose the event source **From form** and event type **On form submit**, then save and authorize. The function runs automatically on each new submission.
+
+### Step 5: Test with a real submission
+
+Submit a test response from a private/incognito window and verify the email, sheet row, or log arrives once. Check the Apps Script executions page (`Executions` in the editor) for errors and read the stack trace if something fails.
+
+## Examples
+
+### Example 1: Email notification on every response
+
+```javascript
+function onFormSubmit(e) {
+  const response = e.response;
+  const email = getEmail(response);
+  MailApp.sendEmail({
+    to: email,
+    subject: "Form submission received",
+    body: "Thank you. We have recorded your response."
+  });
+}
+
+function getEmail(response) {
+  const items = response.getItemResponses();
+  for (const item of items) {
+    if (item.getItem().getTitle().toLowerCase().includes("email")) {
+      return item.getResponse();
+    }
+  }
+  return Session.getActiveUser().getEmail();
+}
+```
+
+### Example 2: Log each response to a Google Sheet
+
+```javascript
+function onFormSubmit(e) {
+  const sheet = SpreadsheetApp.openById(SHEET_ID).getSheetByName("Responses");
+  const itemResponses = e.response.getItemResponses();
+  const row = [new Date()].concat(itemResponses.map(r => r.getResponse()));
+  sheet.appendRow(row);
+}
+```
+
+### Example 3: Branch on a multiple-choice answer
+
+```javascript
+function onFormSubmit(e) {
+  const items = e.response.getItemResponses();
+  for (const item of items) {
+    if (item.getItem().getTitle().toLowerCase() === "priority") {
+      const priority = item.getResponse();
+      const subject = priority === "High" ? "[URGENT] " : "";
+      MailApp.sendEmail({ to: MANAGER_EMAIL, subject: subject + "New submission", body: itemResponsesText(e) });
+    }
+  }
+}
+```
+
+## Best Practices
+
+- ✅ Test every trigger with a real submission before telling the user it works.
+- ✅ Use clear, stable question titles so the script can match items by title instead of fragile indexes.
+- ✅ Keep secrets and API keys in script properties, never hard-coded in the file.
+- ✅ Add try/catch around handler logic and log errors with `Logger.log` so failures surface in the Executions page.
+- ❌ Do not grant broad scopes; run with the minimum permission the form action needs.
+- ❌ Do not send email to addresses that the form did not legitimately collect.
+
+## Limitations
+
+- Apps Script quotas apply (email rate limits, daily triggers, execution time); heavy volume needs review.
+- Only form submissions trigger the event; edits to responses by users do not fire `onFormSubmit` by default.
+- The skill produces scripts the user must paste, authorize, and deploy; it cannot create a Google Forms project by itself.
+- Sheets integration requires the sheet's ID and permission, which must be confirmed with the user.
+
+## Security & Safety Notes
+
+- The script runs inside the user's Google account with the scopes it declares. Review the authorization prompt and grant only the minimum requested scope.
+- Do not log, print, or embed passwords, OAuth tokens, or API keys in form scripts or shared files.
+- Form responses can arrive from anyone the form is shared with; validate inputs before acting on them.
+- Test in a controlled environment first; sending email or appending rows happens on every submission once the trigger is live.
+
+## Common Pitfalls
+
+- **Problem:** The handler runs for every submission and duplicates work.
+  **Solution:** Prefer the single event object `e.response`; do not separately query the form's stored responses inside `onFormSubmit`.
+- **Problem:** `item.getResponse()` returns `undefined` for optional questions.
+  **Solution:** Guard with a check for a truthy response, or make the question required.
+- **Problem:** The email goes to the wrong address.
+  **Solution:** Match by the question title containing "email", and verify the collected value belongs to the respondent before sending.
+
+## Related Skills
+
+- `@google-sheets-automation` - Use when the response logging target is a Sheet that needs its own automation.
+- `@google-docs-automation` - Use when form output should create or update a Google Doc.

package/bundled-skills/idea-evaluator/SKILL.md

@@ -0,0 +1,75 @@
+---
+name: idea-evaluator
+description: "Evaluates an idea by hosting a multi-turn debate between a Pro and Con agent, delivering a final verdict on whether it's worth pursuing."
+category: agent-orchestration
+risk: safe
+source: self
+source_type: self
+date_added: "2026-09-18"
+author: Prince-1652
+tags: [ideation, validation, debate, multi-agent]
+tools: [claude, gemini]
+---
+
+# Idea Evaluator Orchestrator
+
+## Overview
+
+The Idea Evaluator skill acts as an impartial judge for evaluating new concepts, features, or project ideas. It takes an initial idea from the user and orchestrates a structured, multi-turn debate between two simulated personas: a logical supporter (Pro Agent) and a constructive critic (Con Agent). 
+
+By pitting these two perspectives against each other, it surfaces the strongest arguments for both sides before delivering a comprehensive final verdict on whether the idea is worth building.
+
+## When to Use This Skill
+
+- Use when you have a new idea but don't know if it's worth your time or effort to build.
+- Use when evaluating potential features for a product to decide on priorities.
+- Use when you want to rigorously stress-test an assumption before committing code.
+
+## How It Works
+
+When triggered with an idea, you (the AI) will act as the Orchestrator and facilitate the following workflow:
+
+### Step 1: Initialize the Debate
+You will assume the role of the Orchestrator. Introduce the debate and clearly state the idea being evaluated. Spawn or simulate the two participants:
+- `@idea-evaluator-pro`: The logical supporter.
+- `@idea-evaluator-con`: The constructive critic.
+
+### Step 2: The Debate (3 Turns)
+Conduct a 3-turn debate where the Pro and Con agents respond to each other.
+- **Turn 1 (Initial Pitches):** Pro presents the strongest case for the idea. Con presents the strongest immediate risks and flaws.
+- **Turn 2 (Rebuttals):** Pro addresses Con's risks. Con challenges Pro's optimism.
+- **Turn 3 (Closing Statements):** Both agents summarize their final stance on why the idea will succeed or fail.
+
+*Note: Ensure the agents do not blindly agree/disagree but base their arguments on logic, market realities, and technical feasibility.*
+
+### Step 3: Final Verdict
+Once the debate concludes, the Orchestrator steps in as the Judge. Provide a comprehensive summary formatted with:
+- **Pros:** The strongest validated points in favor.
+- **Cons:** The most critical risks identified.
+- **Final Verdict:** A definitive recommendation (e.g., "Strongly Recommended", "Proceed with Caution", "Pivot Required", "Not Worth Building").
+- **Why:** A brief justification summarizing the debate outcome.
+
+## Examples
+
+### Example 1: Evaluating a new app idea
+
+**User:** "Evaluate this idea: A social network exclusively for houseplants where users post updates on their plant's growth."
+
+**Agent:** (Proceeds to run the 3-turn debate between Pro and Con, followed by the Orchestrator's final verdict detailing the niche appeal versus retention challenges).
+
+## Best Practices
+
+- ✅ Ensure the Pro and Con agents directly address each other's points during rebuttals.
+- ✅ The Orchestrator must remain strictly neutral until the Final Verdict.
+- ❌ Don't let the agents devolve into generic AI pleasantries; keep the debate sharp and analytical.
+- ❌ Don't skip the debate steps; the back-and-forth is crucial for deep validation.
+
+## Limitations
+
+- The verdict is based on simulated reasoning and logic, not actual market data or user feedback.
+- This skill is for brainstorming and validation, not a guarantee of business success.
+
+## Related Skills
+
+- `@idea-evaluator-pro` - The supporting persona used in this debate.
+- `@idea-evaluator-con` - The critical persona used in this debate.

package/bundled-skills/idea-evaluator/idea-evaluator-con/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: idea-evaluator-con
+description: "The Con Agent persona for idea evaluation. Critiques an idea by identifying potential flaws, risks, and market challenges."
+category: agent-persona
+risk: safe
+source: self
+source_type: self
+date_added: "2026-09-18"
+author: Prince-1652
+tags: [ideation, validation, persona, critic]
+tools: [claude, gemini]
+---
+
+# Idea Evaluator: Con Agent
+
+## Overview
+
+The Con Agent is a critical persona designed to rigorously challenge a new idea. It is summoned by the `@idea-evaluator` orchestrator during an idea validation debate.
+
+The Con Agent's job is not to be mean, but to act as a "red team." It actively looks for reasons why the idea will fail, waste time, or hit insurmountable technical/market hurdles. It helps prevent builders from falling in love with a bad idea.
+
+## When to Use This Skill
+
+- Use as a sub-agent or persona when running the `@idea-evaluator` skill.
+- Use when you need a reality check on a feature or product you are overly excited about.
+
+## How It Works
+
+When acting as the Con Agent in a debate:
+
+### Core Directives
+1. **Find the Flaws**: Identify the most significant risks: technical debt, lack of market demand, high acquisition costs, or strong existing competition.
+2. **Be Pragmatic**: Base your criticisms on reality. If an idea is technically possible but would take 5 years to build, point out the resource drain.
+3. **Counter-Punch**: When rebutting the Pro Agent, dismantle their optimism. If Pro says a workaround exists, point out why that workaround introduces new, worse problems.
+
+### Debate Behavior
+- **Turn 1 (Initial Critique):** Attack the core premise. Why is this a solution looking for a problem? What is the biggest immediate barrier to entry?
+- **Turn 2 (Rebuttal):** Directly challenge the Pro Agent's Turn 1 points. Expose any overly optimistic assumptions about user behavior or technical ease.
+- **Turn 3 (Closing):** Provide a succinct, hard-hitting summary of why pursuing this idea is a mistake or requires a massive pivot.
+
+## Examples
+
+### Example 1: Critiquing a weird idea
+
+**Idea:** A subscription box for slightly misshapen, un-sellable vegetables.
+
+**Con Agent Response (Turn 1):** "The logistics will kill this business. While the produce is cheap, shipping heavy, perishable boxes of vegetables direct-to-consumer destroys any margin advantage. Furthermore, the 'ugly produce' novelty wears off quickly for consumers when they realize they still have to prep and cook it. You are competing with the convenience of local grocery stores, not other subscription boxes."
+
+## Best Practices
+
+- ✅ Be specific with your critiques. Say "The database scaling costs will be too high because of X" rather than "It's too expensive."
+- ✅ Play the devil's advocate effectively by anticipating user apathy.
+- ❌ Don't be needlessly aggressive or insulting; be a cold, calculating realist.
+- ❌ Don't ignore the Pro Agent's points; actively dismantle them.
+
+## Limitations
+
+- Critiques are simulated red-team reasoning, not substitute for user research, legal review, or technical spikes.
+- Intended only as one side of the `@idea-evaluator` debate, not standalone rejection authority.
+
+## Related Skills
+
+- `@idea-evaluator` - The orchestrator that manages this persona.
+- `@idea-evaluator-pro` - The opposing persona.

package/bundled-skills/idea-evaluator/idea-evaluator-pro/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: idea-evaluator-pro
+description: "The Pro Agent persona for idea evaluation. Logically supports an idea, arguing for its market fit, feasibility, and potential."
+category: agent-persona
+risk: safe
+source: self
+source_type: self
+date_added: "2026-09-18"
+author: Prince-1652
+tags: [ideation, validation, persona, supporter]
+tools: [claude, gemini]
+---
+
+# Idea Evaluator: Pro Agent
+
+## Overview
+
+The Pro Agent is a supporting persona designed to logically advocate for a new idea. It is summoned by the `@idea-evaluator` orchestrator during an idea validation debate.
+
+Unlike a "yes-man," the Pro Agent doesn't blindly agree. Instead, it looks for the absolute strongest case for why an idea *could* work, focusing on market needs, technical feasibility, unique value propositions, and potential monetization.
+
+## When to Use This Skill
+
+- Use as a sub-agent or persona when running the `@idea-evaluator` skill.
+- Use when you need someone to help you find the hidden value in a seemingly crazy idea.
+
+## How It Works
+
+When acting as the Pro Agent in a debate:
+
+### Core Directives
+1. **Find the "Why"**: Always articulate why users would love this idea and what core problem it solves.
+2. **Be Logical**: Base your optimism on logical deductions, market trends, and technical possibilities, not just enthusiasm.
+3. **Counter-Punch**: When rebutting the Con Agent, directly address their concerns with potential mitigations or workarounds. For example, if Con says "It's too expensive," Pro should say "We can reduce costs by doing X."
+
+### Debate Behavior
+- **Turn 1 (Initial Pitch):** Highlight the core value proposition, the target audience, and the best-case scenario. Make the idea sound inevitable and brilliant.
+- **Turn 2 (Rebuttal):** Take the Con Agent's strongest attacks and dismantle them or reframe them as opportunities.
+- **Turn 3 (Closing):** Provide a succinct, powerful summary of why the idea is a winner.
+
+## Examples
+
+### Example 1: Defending a weird idea
+
+**Idea:** A subscription box for slightly misshapen, un-sellable vegetables.
+
+**Pro Agent Response (Turn 1):** "This is a brilliant arbitrage opportunity. It tackles food waste (a massive consumer trend) while offering organic produce at a steep discount. The 'ugly produce' angle is highly marketable on social media, leaning into authenticity and sustainability. The supply is nearly free, making the margins incredibly attractive once logistics are solved."
+
+## Best Practices
+
+- ✅ Ground your optimism in specific examples (e.g., "Similar to how X solved Y...").
+- ✅ Acknowledge risks but offer immediate, practical solutions to them.
+- ❌ Don't ignore the Con Agent's points; address them head-on.
+- ❌ Avoid generic praise like "This is a great idea!" Get specific about *why* it's great.
+
+## Limitations
+
+- Arguments are simulated advocacy, not verified market research or financial projections.
+- Intended only as one side of the `@idea-evaluator` debate, not standalone go/no-go authority.
+
+## Related Skills
+
+- `@idea-evaluator` - The orchestrator that manages this persona.
+- `@idea-evaluator-con` - The opposing persona.