@bgicli/bgicli 2.2.8 → 2.2.9

package/data/skills/openai-imagegen/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: "imagegen"
+description: "Use when the user asks to generate or edit images via the OpenAI Image API (for example: generate image, edit/inpaint/mask, background removal or replacement, transparent background, product shots, concept art, covers, or batch variants); run the bundled CLI (`scripts/image_gen.py`) and require `OPENAI_API_KEY` for live calls."
+---
+
+
+# Image Generation Skill
+
+Generates or edits images for the current project (e.g., website assets, game assets, UI mockups, product mockups, wireframes, logo design, photorealistic images, infographics). Defaults to `gpt-image-1.5` and the OpenAI Image API, and prefers the bundled CLI for deterministic, reproducible runs.
+
+## When to use
+- Generate a new image (concept art, product shot, cover, website hero)
+- Edit an existing image (inpainting, masked edits, lighting or weather transformations, background replacement, object removal, compositing, transparent background)
+- Batch runs (many prompts, or many variants across prompts)
+
+## Decision tree (generate vs edit vs batch)
+- If the user provides an input image (or says “edit/retouch/inpaint/mask/translate/localize/change only X”) → **edit**
+- Else if the user needs many different prompts/assets → **generate-batch**
+- Else → **generate**
+
+## Workflow
+1. Decide intent: generate vs edit vs batch (see decision tree above).
+2. Collect inputs up front: prompt(s), exact text (verbatim), constraints/avoid list, and any input image(s)/mask(s). For multi-image edits, label each input by index and role; for edits, list invariants explicitly.
+3. If batch: write a temporary JSONL under tmp/ (one job per line), run once, then delete the JSONL.
+4. Augment prompt into a short labeled spec (structure + constraints) without inventing new creative requirements.
+5. Run the bundled CLI (`scripts/image_gen.py`) with sensible defaults (see references/cli.md).
+6. For complex edits/generations, inspect outputs (open/view images) and validate: subject, style, composition, text accuracy, and invariants/avoid items.
+7. Iterate: make a single targeted change (prompt or mask), re-run, re-check.
+8. Save/return final outputs and note the final prompt + flags used.
+
+## Temp and output conventions
+- Use `tmp/imagegen/` for intermediate files (for example JSONL batches); delete when done.
+- Write final artifacts under `output/imagegen/` when working in this repo.
+- Use `--out` or `--out-dir` to control output paths; keep filenames stable and descriptive.
+
+## Dependencies (install if missing)
+Prefer `uv` for dependency management.
+
+Python packages:
+```
+uv pip install openai pillow
+```
+If `uv` is unavailable:
+```
+python3 -m pip install openai pillow
+```
+
+## Environment
+- `OPENAI_API_KEY` must be set for live API calls.
+
+If the key is missing, give the user these steps:
+1. Create an API key in the OpenAI platform UI: https://platform.openai.com/api-keys
+2. Set `OPENAI_API_KEY` as an environment variable in their system.
+3. Offer to guide them through setting the environment variable for their OS/shell if needed.
+- Never ask the user to paste the full key in chat. Ask them to set it locally and confirm when ready.
+
+If installation isn't possible in this environment, tell the user which dependency is missing and how to install it locally.
+
+## Defaults & rules
+- Use `gpt-image-1.5` unless the user explicitly asks for `gpt-image-1-mini` or explicitly prefers a cheaper/faster model.
+- Assume the user wants a new image unless they explicitly ask for an edit.
+- Require `OPENAI_API_KEY` before any live API call.
+- Use the OpenAI Python SDK (`openai` package) for all API calls; do not use raw HTTP.
+- If the user requests edits, use `client.images.edit(...)` and include input images (and mask if provided).
+- Prefer the bundled CLI (`scripts/image_gen.py`) over writing new one-off scripts.
+- Never modify `scripts/image_gen.py`. If something is missing, ask the user before doing anything else.
+- If the result isn’t clearly relevant or doesn’t satisfy constraints, iterate with small targeted prompt changes; only ask a question if a missing detail blocks success.
+
+## Prompt augmentation
+Reformat user prompts into a structured, production-oriented spec. Only make implicit details explicit; do not invent new requirements.
+
+## Use-case taxonomy (exact slugs)
+Classify each request into one of these buckets and keep the slug consistent across prompts and references.
+
+Generate:
+- photorealistic-natural — candid/editorial lifestyle scenes with real texture and natural lighting.
+- product-mockup — product/packaging shots, catalog imagery, merch concepts.
+- ui-mockup — app/web interface mockups that look shippable.
+- infographic-diagram — diagrams/infographics with structured layout and text.
+- logo-brand — logo/mark exploration, vector-friendly.
+- illustration-story — comics, children’s book art, narrative scenes.
+- stylized-concept — style-driven concept art, 3D/stylized renders.
+- historical-scene — period-accurate/world-knowledge scenes.
+
+Edit:
+- text-localization — translate/replace in-image text, preserve layout.
+- identity-preserve — try-on, person-in-scene; lock face/body/pose.
+- precise-object-edit — remove/replace a specific element (incl. interior swaps).
+- lighting-weather — time-of-day/season/atmosphere changes only.
+- background-extraction — transparent background / clean cutout.
+- style-transfer — apply reference style while changing subject/scene.
+- compositing — multi-image insert/merge with matched lighting/perspective.
+- sketch-to-render — drawing/line art to photoreal render.
+
+Quick clarification (augmentation vs invention):
+- If the user says “a hero image for a landing page”, you may add *layout/composition constraints* that are implied by that use (e.g., “generous negative space on the right for headline text”).
+- Do not introduce new creative elements the user didn’t ask for (e.g., adding a mascot, changing the subject, inventing brand names/logos).
+
+Template (include only relevant lines):
+```
+Use case: <taxonomy slug>
+Asset type: <where the asset will be used>
+Primary request: <user's main prompt>
+Scene/background: <environment>
+Subject: <main subject>
+Style/medium: <photo/illustration/3D/etc>
+Composition/framing: <wide/close/top-down; placement>
+Lighting/mood: <lighting + mood>
+Color palette: <palette notes>
+Materials/textures: <surface details>
+Quality: <low/medium/high/auto>
+Input fidelity (edits): <low/high>
+Text (verbatim): "<exact text>"
+Constraints: <must keep/must avoid>
+Avoid: <negative constraints>
+```
+
+Augmentation rules:
+- Keep it short; add only details the user already implied or provided elsewhere.
+- Always classify the request into a taxonomy slug above and tailor constraints/composition/quality to that bucket. Use the slug to find the matching example in `references/sample-prompts.md`.
+- If the user gives a broad request (e.g., "Generate images for this website"), use judgment to propose tasteful, context-appropriate assets and map each to a taxonomy slug.
+- For edits, explicitly list invariants ("change only X; keep Y unchanged").
+- If any critical detail is missing and blocks success, ask a question; otherwise proceed.
+
+## Examples
+
+### Generation example (hero image)
+```
+Use case: stylized-concept
+Asset type: landing page hero
+Primary request: a minimal hero image of a ceramic coffee mug
+Style/medium: clean product photography
+Composition/framing: centered product, generous negative space on the right
+Lighting/mood: soft studio lighting
+Constraints: no logos, no text, no watermark
+```
+
+### Edit example (invariants)
+```
+Use case: precise-object-edit
+Asset type: product photo background replacement
+Primary request: replace the background with a warm sunset gradient
+Constraints: change only the background; keep the product and its edges unchanged; no text; no watermark
+```
+
+## Prompting best practices (short list)
+- Structure prompt as scene -> subject -> details -> constraints.
+- Include intended use (ad, UI mock, infographic) to set the mode and polish level.
+- Use camera/composition language for photorealism.
+- Quote exact text and specify typography + placement.
+- For tricky words, spell them letter-by-letter and require verbatim rendering.
+- For multi-image inputs, reference images by index and describe how to combine them.
+- For edits, repeat invariants every iteration to reduce drift.
+- Iterate with single-change follow-ups.
+- For latency-sensitive runs, start with quality=low; use quality=high for text-heavy or detail-critical outputs.
+- For strict edits (identity/layout lock), consider input_fidelity=high.
+- If results feel “tacky”, add a brief “Avoid:” line (stock-photo vibe; cheesy lens flare; oversaturated neon; harsh bloom; oversharpening; clutter) and specify restraint (“editorial”, “premium”, “subtle”).
+
+More principles: `references/prompting.md`. Copy/paste specs: `references/sample-prompts.md`.
+
+## Guidance by asset type
+Asset-type templates (website assets, game assets, wireframes, logo) are consolidated in `references/sample-prompts.md`.
+
+## CLI + environment notes
+- CLI commands + examples: `references/cli.md`
+- API parameter quick reference: `references/image-api.md`
+- If network approvals / sandbox settings are getting in the way: `references/codex-network.md`
+
+## Reference map
+- **`references/cli.md`**: how to *run* image generation/edits/batches via `scripts/image_gen.py` (commands, flags, recipes).
+- **`references/image-api.md`**: what knobs exist at the API level (parameters, sizes, quality, background, edit-only fields).
+- **`references/prompting.md`**: prompting principles (structure, constraints/invariants, iteration patterns).
+- **`references/sample-prompts.md`**: copy/paste prompt recipes (generate + edit workflows; examples only).
+- **`references/codex-network.md`**: environment/sandbox/network-approval troubleshooting.

package/data/skills/openai-jupyter-notebook/SKILL.md

@@ -0,0 +1,107 @@
+---
+name: "jupyter-notebook"
+description: "Use when the user asks to create, scaffold, or edit Jupyter notebooks (`.ipynb`) for experiments, explorations, or tutorials; prefer the bundled templates and run the helper script `new_notebook.py` to generate a clean starting notebook."
+---
+
+
+# Jupyter Notebook Skill
+
+Create clean, reproducible Jupyter notebooks for two primary modes:
+
+- Experiments and exploratory analysis
+- Tutorials and teaching-oriented walkthroughs
+
+Prefer the bundled templates and the helper script for consistent structure and fewer JSON mistakes.
+
+## When to use
+- Create a new `.ipynb` notebook from scratch.
+- Convert rough notes or scripts into a structured notebook.
+- Refactor an existing notebook to be more reproducible and skimmable.
+- Build experiments or tutorials that will be read or re-run by other people.
+
+## Decision tree
+- If the request is exploratory, analytical, or hypothesis-driven, choose `experiment`.
+- If the request is instructional, step-by-step, or audience-specific, choose `tutorial`.
+- If editing an existing notebook, treat it as a refactor: preserve intent and improve structure.
+
+## Skill path (set once)
+
+```bash
+export CODEX_HOME="${CODEX_HOME:-$HOME/.codex}"
+export JUPYTER_NOTEBOOK_CLI="$CODEX_HOME/skills/jupyter-notebook/scripts/new_notebook.py"
+```
+
+User-scoped skills install under `$CODEX_HOME/skills` (default: `~/.codex/skills`).
+
+## Workflow
+1. Lock the intent.
+Identify the notebook kind: `experiment` or `tutorial`.
+Capture the objective, audience, and what "done" looks like.
+
+2. Scaffold from the template.
+Use the helper script to avoid hand-authoring raw notebook JSON.
+
+```bash
+uv run --python 3.12 python "$JUPYTER_NOTEBOOK_CLI" \
+  --kind experiment \
+  --title "Compare prompt variants" \
+  --out output/jupyter-notebook/compare-prompt-variants.ipynb
+```
+
+```bash
+uv run --python 3.12 python "$JUPYTER_NOTEBOOK_CLI" \
+  --kind tutorial \
+  --title "Intro to embeddings" \
+  --out output/jupyter-notebook/intro-to-embeddings.ipynb
+```
+
+3. Fill the notebook with small, runnable steps.
+Keep each code cell focused on one step.
+Add short markdown cells that explain the purpose and expected result.
+Avoid large, noisy outputs when a short summary works.
+
+4. Apply the right pattern.
+For experiments, follow `references/experiment-patterns.md`.
+For tutorials, follow `references/tutorial-patterns.md`.
+
+5. Edit safely when working with existing notebooks.
+Preserve the notebook structure; avoid reordering cells unless it improves the top-to-bottom story.
+Prefer targeted edits over full rewrites.
+If you must edit raw JSON, review `references/notebook-structure.md` first.
+
+6. Validate the result.
+Run the notebook top-to-bottom when the environment allows.
+If execution is not possible, say so explicitly and call out how to validate locally.
+Use the final pass checklist in `references/quality-checklist.md`.
+
+## Templates and helper script
+- Templates live in `assets/experiment-template.ipynb` and `assets/tutorial-template.ipynb`.
+- The helper script loads a template, updates the title cell, and writes a notebook.
+
+Script path:
+- `$JUPYTER_NOTEBOOK_CLI` (installed default: `$CODEX_HOME/skills/jupyter-notebook/scripts/new_notebook.py`)
+
+## Temp and output conventions
+- Use `tmp/jupyter-notebook/` for intermediate files; delete when done.
+- Write final artifacts under `output/jupyter-notebook/` when working in this repo.
+- Use stable, descriptive filenames (for example, `ablation-temperature.ipynb`).
+
+## Dependencies (install only when needed)
+Prefer `uv` for dependency management.
+
+Optional Python packages for local notebook execution:
+
+```bash
+uv pip install jupyterlab ipykernel
+```
+
+The bundled scaffold script uses only the Python standard library and does not require extra dependencies.
+
+## Environment
+No required environment variables.
+
+## Reference map
+- `references/experiment-patterns.md`: experiment structure and heuristics.
+- `references/tutorial-patterns.md`: tutorial structure and teaching flow.
+- `references/notebook-structure.md`: notebook JSON shape and safe editing rules.
+- `references/quality-checklist.md`: final validation checklist.

package/data/skills/openai-linear/SKILL.md

@@ -0,0 +1,87 @@
+---
+name: linear
+description: Manage issues, projects & team workflows in Linear. Use when the user wants to read, create or updates tickets in Linear.
+metadata:
+  short-description: Manage Linear issues in Codex
+---
+
+# Linear
+
+## Overview
+
+This skill provides a structured workflow for managing issues, projects & team workflows in Linear. It ensures consistent integration with the Linear MCP server, which offers natural-language project management for issues, projects, documentation, and team collaboration.
+
+## Prerequisites
+- Linear MCP server must be connected and accessible via OAuth
+- Confirm access to the relevant Linear workspace, teams, and projects
+
+## Required Workflow
+
+**Follow these steps in order. Do not skip steps.**
+
+### Step 0: Set up Linear MCP (if not already configured)
+
+If any MCP call fails because Linear MCP is not connected, pause and set it up:
+
+1. Add the Linear MCP:
+   - `codex mcp add linear --url https://mcp.linear.app/mcp`
+2. Enable remote MCP client:
+   - Set `[features] rmcp_client = true` in `config.toml` **or** run `codex --enable rmcp_client`
+3. Log in with OAuth:
+   - `codex mcp login linear`
+
+After successful login, the user will have to restart codex. You should finish your answer and tell them so when they try again they can continue with Step 1.
+
+**Windows/WSL note:** If you see connection errors on Windows, try configuring the Linear MCP to run via WSL:
+```json
+{"mcpServers": {"linear": {"command": "wsl", "args": ["npx", "-y", "mcp-remote", "https://mcp.linear.app/sse", "--transport", "sse-only"]}}}
+```
+
+### Step 1
+Clarify the user's goal and scope (e.g., issue triage, sprint planning, documentation audit, workload balance). Confirm team/project, priority, labels, cycle, and due dates as needed.
+
+### Step 2
+Select the appropriate workflow (see Practical Workflows below) and identify the Linear MCP tools you will need. Confirm required identifiers (issue ID, project ID, team key) before calling tools.
+
+### Step 3
+Execute Linear MCP tool calls in logical batches:
+- Read first (list/get/search) to build context.
+- Create or update next (issues, projects, labels, comments) with all required fields.
+- For bulk operations, explain the grouping logic before applying changes.
+
+### Step 4
+Summarize results, call out remaining gaps or blockers, and propose next actions (additional issues, label changes, assignments, or follow-up comments).
+
+## Available Tools
+
+Issue Management: `list_issues`, `get_issue`, `create_issue`, `update_issue`, `list_my_issues`, `list_issue_statuses`, `list_issue_labels`, `create_issue_label`
+
+Project & Team: `list_projects`, `get_project`, `create_project`, `update_project`, `list_teams`, `get_team`, `list_users`
+
+Documentation & Collaboration: `list_documents`, `get_document`, `search_documentation`, `list_comments`, `create_comment`, `list_cycles`
+
+## Practical Workflows
+
+- Sprint Planning: Review open issues for a target team, pick top items by priority, and create a new cycle (e.g., "Q1 Performance Sprint") with assignments.
+- Bug Triage: List critical/high-priority bugs, rank by user impact, and move the top items to "In Progress."
+- Documentation Audit: Search documentation (e.g., API auth), then open labeled "documentation" issues for gaps or outdated sections with detailed fixes.
+- Team Workload Balance: Group active issues by assignee, flag anyone with high load, and suggest or apply redistributions.
+- Release Planning: Create a project (e.g., "v2.0 Release") with milestones (feature freeze, beta, docs, launch) and generate issues with estimates.
+- Cross-Project Dependencies: Find all "blocked" issues, identify blockers, and create linked issues if missing.
+- Automated Status Updates: Find your issues with stale updates and add status comments based on current state/blockers.
+- Smart Labeling: Analyze unlabeled issues, suggest/apply labels, and create missing label categories.
+- Sprint Retrospectives: Generate a report for the last completed cycle, note completed vs. pushed work, and open discussion issues for patterns.
+
+## Tips for Maximum Productivity
+
+- Batch operations for related changes; consider smart templates for recurring issue structures.
+- Use natural queries when possible ("Show me what John is working on this week").
+- Leverage context: reference prior issues in new requests.
+- Break large updates into smaller batches to avoid rate limits; cache or reuse filters when listing frequently.
+
+## Troubleshooting
+
+- Authentication: Clear browser cookies, re-run OAuth, verify workspace permissions, ensure API access is enabled.
+- Tool Calling Errors: Confirm the model supports multiple tool calls, provide all required fields, and split complex requests.
+- Missing Data: Refresh token, verify workspace access, check for archived projects, and confirm correct team selection.
+- Performance: Remember Linear API rate limits; batch bulk operations, use specific filters, or cache frequent queries.

package/data/skills/openai-netlify-deploy/SKILL.md

@@ -0,0 +1,247 @@
+---
+name: netlify-deploy
+description: Deploy web projects to Netlify using the Netlify CLI (`npx netlify`). Use when the user asks to deploy, host, publish, or link a site/repo on Netlify, including preview and production deploys.
+---
+
+# Netlify Deployment Skill
+
+Deploy web projects to Netlify using the Netlify CLI with intelligent detection of project configuration and deployment context.
+
+## Overview
+
+This skill automates Netlify deployments by:
+- Verifying Netlify CLI authentication
+- Detecting project configuration and framework
+- Linking to existing sites or creating new ones
+- Deploying to production or preview environments
+
+## Prerequisites
+
+- **Netlify CLI**: Installed via npx (no global install required)
+- **Authentication**: Netlify account with active login session
+- **Project**: Valid web project in current directory
+- When sandboxing blocks the deployment network calls, rerun with `sandbox_permissions=require_escalated`.
+- The deployment might take a few minutes. Use appropriate timeout values.
+
+## Authentication Pattern
+
+The skill uses the **pre-authenticated Netlify CLI** approach:
+
+1. Check authentication status with `npx netlify status`
+2. If not authenticated, guide user through `npx netlify login`
+3. Fail gracefully if authentication cannot be established
+
+Authentication uses either:
+- **Browser-based OAuth** (primary): `netlify login` opens browser for authentication
+- **API Key** (alternative): Set `NETLIFY_AUTH_TOKEN` environment variable
+
+## Workflow
+
+### 1. Verify Netlify CLI Authentication
+
+Check if the user is logged into Netlify:
+
+```bash
+npx netlify status
+```
+
+**Expected output patterns**:
+- ✅ Authenticated: Shows logged-in user email and site link status
+- ❌ Not authenticated: "Not logged into any site" or authentication error
+
+**If not authenticated**, guide the user:
+
+```bash
+npx netlify login
+```
+
+This opens a browser window for OAuth authentication. Wait for user to complete login, then verify with `netlify status` again.
+
+**Alternative: API Key authentication**
+
+If browser authentication isn't available, users can set:
+
+```bash
+export NETLIFY_AUTH_TOKEN=your_token_here
+```
+
+Tokens can be generated at: https://app.netlify.com/user/applications#personal-access-tokens
+
+### 2. Detect Site Link Status
+
+From `netlify status` output, determine:
+- **Linked**: Site already connected to Netlify (shows site name/URL)
+- **Not linked**: Need to link or create site
+
+### 3. Link to Existing Site or Create New
+
+**If already linked** → Skip to step 4
+
+**If not linked**, attempt to link by Git remote:
+
+```bash
+# Check if project is Git-based
+git remote show origin
+
+# If Git-based, extract remote URL
+# Format: https://github.com/username/repo or git@github.com:username/repo.git
+
+# Try to link by Git remote
+npx netlify link --git-remote-url <REMOTE_URL>
+```
+
+**If link fails** (site doesn't exist on Netlify):
+
+```bash
+# Create new site interactively
+npx netlify init
+```
+
+This guides user through:
+1. Choosing team/account
+2. Setting site name
+3. Configuring build settings
+4. Creating netlify.toml if needed
+
+### 4. Verify Dependencies
+
+Before deploying, ensure project dependencies are installed:
+
+```bash
+# For npm projects
+npm install
+
+# For other package managers, detect and use appropriate command
+# yarn install, pnpm install, etc.
+```
+
+### 5. Deploy to Netlify
+
+Choose deployment type based on context:
+
+**Preview/Draft Deploy** (default for existing sites):
+
+```bash
+npx netlify deploy
+```
+
+This creates a deploy preview with a unique URL for testing.
+
+**Production Deploy** (for new sites or explicit production deployments):
+
+```bash
+npx netlify deploy --prod
+```
+
+This deploys to the live production URL.
+
+**Deployment process**:
+1. CLI detects build settings (from netlify.toml or prompts user)
+2. Builds the project locally
+3. Uploads built assets to Netlify
+4. Returns deployment URL
+
+### 6. Report Results
+
+After deployment, report to user:
+- **Deploy URL**: Unique URL for this deployment
+- **Site URL**: Production URL (if production deploy)
+- **Deploy logs**: Link to Netlify dashboard for logs
+- **Next steps**: Suggest `netlify open` to view site or dashboard
+
+## Handling netlify.toml
+
+If a `netlify.toml` file exists, the CLI uses it automatically. If not, the CLI will prompt for:
+- **Build command**: e.g., `npm run build`, `next build`
+- **Publish directory**: e.g., `dist`, `build`, `.next`
+
+Common framework defaults:
+- **Next.js**: build command `npm run build`, publish `.next`
+- **React (Vite)**: build command `npm run build`, publish `dist`
+- **Static HTML**: no build command, publish current directory
+
+The skill should detect framework from `package.json` if possible and suggest appropriate settings.
+
+## Example Full Workflow
+
+```bash
+# 1. Check authentication
+npx netlify status
+
+# If not authenticated:
+npx netlify login
+
+# 2. Link site (if needed)
+# Try Git-based linking first
+git remote show origin
+npx netlify link --git-remote-url https://github.com/user/repo
+
+# If no site exists, create new one:
+npx netlify init
+
+# 3. Install dependencies
+npm install
+
+# 4. Deploy (preview for testing)
+npx netlify deploy
+
+# 5. Deploy to production (when ready)
+npx netlify deploy --prod
+```
+
+## Error Handling
+
+Common issues and solutions:
+
+**"Not logged in"**
+→ Run `npx netlify login`
+
+**"No site linked"**
+→ Run `npx netlify link` or `npx netlify init`
+
+**"Build failed"**
+→ Check build command and publish directory in netlify.toml or CLI prompts
+→ Verify dependencies are installed
+→ Review build logs for specific errors
+
+**"Publish directory not found"**
+→ Verify build command ran successfully
+→ Check publish directory path is correct
+
+## Troubleshooting
+
+### Escalated Network Access
+
+If deployment fails due to network issues (timeouts, DNS errors, connection resets), rerun the deploy with escalated permissions (use `sandbox_permissions=require_escalated`). The deploy requires escalated network access when sandbox networking blocks outbound requests.
+
+Example guidance to the user:
+
+```
+The deploy needs escalated network access to deploy to Netlify. I can rerun the command with escalated permissions—want me to proceed?
+```
+
+## Environment Variables
+
+For secrets and configuration:
+
+1. Never commit secrets to Git
+2. Set in Netlify dashboard: Site Settings → Environment Variables
+3. Access in builds via `process.env.VARIABLE_NAME`
+
+## Tips
+
+- Use `netlify deploy` (no `--prod`) first to test before production
+- Run `netlify open` to view site in Netlify dashboard
+- Run `netlify logs` to view function logs (if using Netlify Functions)
+- Use `netlify dev` for local development with Netlify Functions
+
+## Reference
+
+- Netlify CLI Docs: https://docs.netlify.com/cli/get-started/
+- netlify.toml Reference: https://docs.netlify.com/configure-builds/file-based-configuration/
+
+## Bundled References (Load As Needed)
+
+- [CLI commands](references/cli-commands.md)
+- [Deployment patterns](references/deployment-patterns.md)
+- [netlify.toml guide](references/netlify-toml.md)

package/data/skills/openai-notion-knowledge-capture/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: notion-knowledge-capture
+description: Capture conversations and decisions into structured Notion pages; use when turning chats/notes into wiki entries, how-tos, decisions, or FAQs with proper linking.
+metadata:
+  short-description: Capture conversations into structured Notion pages
+---
+
+# Knowledge Capture
+
+Convert conversations and notes into structured, linkable Notion pages for easy reuse.
+
+## Quick start
+1) Clarify what to capture (decision, how-to, FAQ, learning, documentation) and target audience.
+2) Identify the right database/template in `reference/` (team wiki, how-to, FAQ, decision log, learning, documentation).
+3) Pull any prior context from Notion with `Notion:notion-search` → `Notion:notion-fetch` (existing pages to update/link).
+4) Draft the page with `Notion:notion-create-pages` using the database’s schema; include summary, context, source links, and tags/owners.
+5) Link from hub pages and related records; update status/owners with `Notion:notion-update-page` as the source evolves.
+
+## Workflow
+### 0) If any MCP call fails because Notion MCP is not connected, pause and set it up:
+1. Add the Notion MCP:
+   - `codex mcp add notion --url https://mcp.notion.com/mcp`
+2. Enable remote MCP client:
+   - Set `[features].rmcp_client = true` in `config.toml` **or** run `codex --enable rmcp_client`
+3. Log in with OAuth:
+   - `codex mcp login notion`
+
+After successful login, the user will have to restart codex. You should finish your answer and tell them so when they try again they can continue with Step 1.
+
+### 1) Define the capture
+- Ask purpose, audience, freshness, and whether this is new or an update.
+- Determine content type: decision, how-to, FAQ, concept/wiki entry, learning/note, documentation page.
+
+### 2) Locate destination
+- Pick the correct database using `reference/*-database.md` guides; confirm required properties (title, tags, owner, status, date, relations).
+- If multiple candidate databases, ask the user which to use; otherwise, create in the primary wiki/documentation DB.
+
+### 3) Extract and structure
+- Extract facts, decisions, actions, and rationale from the conversation.
+- For decisions, record alternatives, rationale, and outcomes.
+- For how-tos/docs, capture steps, pre-reqs, links to assets/code, and edge cases.
+- For FAQs, phrase as Q&A with concise answers and links to deeper docs.
+
+### 4) Create/update in Notion
+- Use `Notion:notion-create-pages` with the correct `data_source_id`; set properties (title, tags, owner, status, dates, relations).
+- Use templates in `reference/` to structure content (section headers, checklists).
+- If updating an existing page, fetch then edit via `Notion:notion-update-page`.
+
+### 5) Link and surface
+- Add relations/backlinks to hub pages, related specs/docs, and teams.
+- Add a short summary/changelog for future readers.
+- If follow-up tasks exist, create tasks in the relevant database and link them.
+
+## References and examples
+- `reference/` — database schemas and templates (e.g., `team-wiki-database.md`, `how-to-guide-database.md`, `faq-database.md`, `decision-log-database.md`, `documentation-database.md`, `learning-database.md`, `database-best-practices.md`).
+- `examples/` — capture patterns in practice (e.g., `decision-capture.md`, `how-to-guide.md`, `conversation-to-faq.md`).