Copy ans send this exact prompt to install all Notion Skill Registry skills ⬇️⬇️⬇️

# Notion Skills Bundle

This file combines the current contents of:

- `notion-init/SKILL.md`
- `notion-install/SKILL.md`
- `notion-update/SKILL.md`
- `notion-check-updates/SKILL.md`

Make sure you will create folder with {skill-name} and then inside of it create SKILL.md file with contents of skill.
---
---
name: notion-init
description: |
  Initializes a project-local Notion skill registry for OpenCode or Claude-style
  repos. Use when the current repository wants to install Notion-hosted skills
  into `.opencode/skills/{skill-name}/SKILL.md` or `.claude/skills/{skill-name}/SKILL.md`
  and track them in a local manifest.
version: 1.0.0
user-invocable: true
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Grep
  - Glob
  - AskUserQuestion
metadata:
  author: niko
  category: notion-registry
---

# Notion Init

Initialize the local Notion-backed skill registry for the current project.

## Goal

Set up a project-local manifest that will later be used to install generated wrapper skills into:

- `.opencode/skills/{skill-name}/SKILL.md`
- `.claude/skills/{skill-name}/SKILL.md`

The manifest file should live in the same local config root:

- `.opencode/notion-skills.json`
- `.claude/notion-skills.json`

## Important scope rule

Do not write to global config folders like:

- `~/.config/opencode`
- `~/.config/claude`

Only work inside the current repository.

## Detection rules

1. Check whether `.opencode/` exists in the current project root.
2. Check whether `.claude/` exists in the current project root.

Choose target root like this:

- If `.opencode/` exists and `.claude/` does not, use `.opencode/`
- If `.claude/` exists and `.opencode/` does not, use `.claude/`
- If both exist, ask the user which one to initialize
- If neither exists, ask the user which one to create
- Default to `.opencode/` if the user has no preference

## What to create

Inside the chosen root, ensure these paths exist:

- `{root}/skills/`
- `{root}/notion-skills.json`

Where `{root}` is either `.opencode` or `.claude`.

## Manifest format

Create or repair the manifest using exactly this shape:

```json
{
  "registryVersion": 1,
  "provider": "notion",
  "root": ".opencode",
  "notion": {
    "mcpServer": "notion",
    "skillRegistryPageId": "REPLACE_ME"
  },
  "skills": {}
}

If the root is .claude, then "root" should be ".claude".

Registry page ID

This manifest must store the Notion page ID for the skill registry index page.

The registry is a regular Notion page, not a database. It contains grouped skill version links like:

• Content Creator
  • content-creator@v1 - approved
  • content-creator@v2 - approved
• Digest writer
  • digest-writer@v1 - approved

If a manifest already exists:

• Reuse the existing notion.skillRegistryPageId if present

If it is missing:

Ask the user:

Please provide the Notion Skill Registry page ID or full Notion URL.

Then normalize it:

• Accept either raw ID or full URL
• Extract the final 32-character Notion page ID if a URL is provided
• Accept dashed or undashed input
• Store the undashed form if possible

If parsing fails, ask once more clearly.

If the manifest already exists

Read it first and preserve any installed skills.

Repair rules:

• If registryVersion is missing, set it to 1
• If provider is missing, set it to "notion"
• If root is missing, set it to the chosen local root
• If notion is missing, create it
• If notion.mcpServer is missing, set it to "notion"
• If notion.skillRegistryPageId is missing, ask the user and set it
• If legacy notion.skillVersionsDataSourceId exists, migrate its value into notion.skillRegistryPageId and remove the legacy field
• If skills is missing, set it to {}

Do not delete or rewrite existing skill records unnecessarily.

Backup rules

If {root}/notion-skills.json already exists:

• Create a backup first: {root}/notion-skills.json.bak

What this manifest is for

This file tracks which remote Notion skills are installed locally into:

• {root}/skills/{skill-name}/SKILL.md

Later commands like notion-install, notion-update, and notion-check-updates will use it.

Do not do these things

• Do not install any actual skills yet
• Do not write anything into ~/.config/opencode
• Do not create global skills
• Do not query unrelated Notion content
• Do not overwrite an existing valid manifest unnecessarily

Implementation steps

1. Detect .opencode/ and .claude/ in the current repo.
2. Select the target root using the detection rules above.
3. Ensure {root}/skills/ exists.
4. Read {root}/notion-skills.json if it exists.
5. Determine whether a valid registry page ID is already present.
6. If not, ask the user for it and normalize it.
7. Create or repair the manifest.
8. Write pretty JSON with 2-space indentation.
9. Re-read the file to verify correctness.
10. Report what was created or repaired.

Success output

At the end, report:

• Which root was initialized (.opencode or .claude)
• Manifest path
• Whether it was created or updated
• Configured Notion registry page ID
• Current number of tracked installed skills

Example valid result for OpenCode

{
  "registryVersion": 1,
  "provider": "notion",
  "root": ".opencode",
  "notion": {
    "mcpServer": "notion",
    "skillRegistryPageId": "31f186f0c3d98061bd19d38cba879b4b"
  },
  "skills": {}
}

Example valid result for Claude-style repo

{
  "registryVersion": 1,
  "provider": "notion",
  "root": ".claude",
  "notion": {
    "mcpServer": "notion",
    "skillRegistryPageId": "31f186f0c3d98061bd19d38cba879b4b"
  },
  "skills": {}
}

name: notion-install description: | Installs a project-local wrapper skill from the Notion skill registry into .opencode/skills/{skill-name}/SKILL.md or .claude/skills/{skill-name}/SKILL.md. Use when a repository wants to consume a Notion-hosted skill without copying the full skill text manually. version: 1.0.0 user-invocable: true allowed-tools:

• Read
• Write
• Edit
• Bash
• Grep
• Glob
• AskUserQuestion metadata: author: niko category: notion-registry

Notion Install

Install one skill from the Notion skill registry into the current project. Make sure to always check if Skill page has any subpages/children and to install/copy all of them inside the skill directory.

Goal

Create a local wrapper skill at one of these paths:

• .opencode/skills/{slug}/SKILL.md
• .claude/skills/{slug}/SKILL.md

and record it in the local manifest:

• .opencode/notion-skills.json
• .claude/notion-skills.json

Scope rules

• Only work inside the current repository.
• Do not write to ~/.config/opencode or any global config.
• Use the local manifest created by notion-init.

Detection rules

1. Detect .opencode/ and .claude/ in the current repo.
2. Read the corresponding local manifest:
   • .opencode/notion-skills.json
   • or .claude/notion-skills.json
3. If both roots exist, prefer the one whose manifest exists.
4. If neither manifest exists, stop and tell the user to run notion-init first.

Required input

Determine the skill name from the user request.

If the skill name is not explicit, ask:

Which skill slug should I install from Notion?

Optionally detect an explicit version from the request.

If no version is specified

Install latest-approved.

If a version is specified

Install that exact version.

Notion registry lookup

Use the Notion MCP server referenced by the local manifest under:

• notion.mcpServer

Fetch the Notion skill registry page identified by:

• notion.skillRegistryPageId

This registry is a regular page, not a database. It contains linked version pages grouped by skill, for example:

• Content Creator
  • content-creator@v1 - approved
  • content-creator@v2 - approved

Use Notion MCP tools to:

1. Fetch the registry page directly by page ID or page URL
2. Read block children recursively until the relevant section and links are visible
3. Resolve the target version page from the registry page links

Resolution rules

If an exact version was requested, such as content-creator@v2:

• find the exact linked page with that version title
• use that linked page directly

If only a slug was requested, such as content-creator:

• find all linked version pages whose title matches content-creator@v*
• prefer ones marked approved in the surrounding text on the registry page
• choose the highest version number among approved versions
• if approval text is missing, choose the highest version number found and report that approval state could not be confirmed

Fallback rule

If the registry page does not expose enough detail to resolve the target skill cleanly:

• fall back once to workspace search for the exact page title like content-creator@v2
• do not do broad exploratory search unless the exact-title lookup fails

Wrapper skill to generate

Create a local SKILL.md with frontmatter and instructions that load the exact Notion page.

The generated wrapper should follow this structure

---
name: content-creator
version: v2
description: |
  Wrapper for the remote Notion-hosted `content-creator` skill.
metadata:
  author: niko
  installed_from: notion
  installed_version: "v2"
  tracking: "latest-approved"
  source_page_id: "31f186f0c3d98061bd19d38cba879b4b"
allowed-tools:
  - Read
  - Write
  - Edit
  - Bash
  - Grep
  - Glob
  - AskUserQuestion
---

# Content Creator

Load and apply this exact remote skill from Notion MCP:

- Page id: `31f186f0c3d98061bd19d38cba879b4b`

## Steps

1. Retrieve the exact Notion page.
2. Retrieve page/block children recursively until the whole page is loaded.
3. Use that page content as the active skill instructions for this session.
4. Do not search unrelated Notion pages.
5. Immediately follow the remote skill instructions.

Tracking mode

When installing, record one of these tracking modes in the manifest:

• latest-approved if no exact version was requested
• pinned if a specific version was requested

Manifest update rules

After generating the wrapper, update the local manifest under skills[slug].

Store at least:

{
  "slug": "security-baseline",
  "installedVersion": "v2",
  "tracking": "latest-approved",
  "pageId": "31f186f0c3d98061bd19d38cba879b4b",
  "localSkillPath": ".opencode/skills/security-baseline/SKILL.md",
  "updatedAt": "ISO_TIMESTAMP"
}

Safety rules

• If the local skill folder already exists, back up SKILL.md to SKILL.md.bak before overwriting
• Never overwrite unrelated files
• Never install into both .opencode and .claude at once

Do not do these things

• Do not write to global config
• Do not copy the full remote skill text into the local wrapper
• Do not search unrelated Notion content after the exact page is known

Implementation steps

1. Detect local manifest.
2. Resolve target root.
3. Determine slug and optional version.
4. Fetch the configured registry page.
5. Resolve the target version page from the linked entries on that page.
6. Generate the local wrapper skill.
7. Update the manifest.
8. Report what was installed.

Success output

At the end, report:

• local root used
• installed slug
• installed version
• tracking mode
• source page ID
• local skill path

name: notion-check-updates description: | Checks whether project-local Notion-backed wrapper skills are outdated without modifying any files. Use when you want to compare installed versions against the Notion registry page. version: 1.0.0 user-invocable: true allowed-tools:

• Read
• Bash
• Grep
• Glob
• AskUserQuestion metadata: author: niko category: notion-registry

Notion Check Updates

Check for newer versions of installed Notion-backed skills without changing local files.

Goal

Inspect the local manifest and report whether each tracked skill is:

• up to date
• outdated
• pinned
• missing from the registry

Scope rules

• Read-only mode only
• Do not write any files
• Do not update wrapper skills

Detection rules

1. Detect .opencode/notion-skills.json and .claude/notion-skills.json.
2. Use the manifest that exists.
3. If neither exists, stop and tell the user to run notion-init first.

Target selection

This command can run with or without a skill name.

If a skill name is provided

• check only that skill

If no skill name is provided

• check all tracked skills in the manifest

Check logic

For each selected skill:

1. Read the manifest entry.
2. Fetch the Notion registry page using the configured skillRegistryPageId.
3. Find the linked version entries for that slug.
4. Determine the latest approved version from the registry page.
5. Compare it against installedVersion.

Resolution rules

• Version pages are linked from the registry page and named like slug@vN
• Prefer entries marked approved on the registry page
• If the registry page is ambiguous, do one exact-title workspace search as fallback

Report rules

• If latest approved version equals installed version:
  • report up to date
• If latest approved version is newer and tracking is latest-approved:
  • report update available
• If latest approved version is newer and tracking is pinned:
  • report newer version exists, but skill is pinned
• If the skill cannot be found on the registry page or by exact-title fallback:
  • report missing from registry

Do not do these things

• Do not write wrapper files
• Do not edit the manifest
• Do not silently change pinned versions

Implementation steps

1. Detect the local manifest.
2. Select one skill or all skills.
3. Fetch the configured registry page.
4. Resolve latest approved versions for the selected skills.
5. Compare with installed versions.
6. Print a concise update report.

Output format

Group results under:

• Up to date
• Update available
• Pinned with newer version available
• Missing from registry

For each skill, include:

• slug
• installed version
• latest approved version if found
• tracking mode

name: notion-update description: | Updates installed project-local Notion-backed wrapper skills by checking the configured registry page and refreshing local wrappers when needed. version: 1.0.0 user-invocable: true allowed-tools:

• Read
• Write
• Edit
• Bash
• Grep
• Glob
• AskUserQuestion metadata: author: niko category: notion-registry

Notion Update

Update installed project-local Notion-backed wrapper skills.

Goal

Refresh generated wrapper skills under:

• .opencode/skills/{skill-name}/SKILL.md
• .claude/skills/{skill-name}/SKILL.md

based on the local manifest.

Scope rules

• Only work in the current repository.
• Do not write to any global config.

Detection rules

1. Detect .opencode/notion-skills.json and .claude/notion-skills.json.
2. Use the manifest that exists.
3. If neither exists, stop and tell the user to run notion-init first.

Target selection

This command can run with or without a skill name.

If a skill name is provided

• Only update that skill.

If no skill name is provided

• Process all tracked skills in the manifest.

Update behavior

Read each manifest entry under skills.

Expected fields include:

• slug
• installedVersion
• tracking
• pageId
• localSkillPath

If tracking = latest-approved

• fetch the registry page from Notion
• resolve the latest approved version for that skill from the linked entries on the registry page
• if the version is newer than installedVersion, regenerate the wrapper
• update manifest metadata

If tracking = pinned

• by default, do not advance to a newer version automatically
• if updating all skills, skip pinned skills and report them as skipped
• if updating a specific pinned skill, reinstall the same pinned version unless the user explicitly asked to move it

Notion lookup

Use the Notion MCP server and registry page from the local manifest.

For each skill:

1. Fetch the configured skillRegistryPageId
2. Read the linked version entries for the matching slug
3. Resolve the target version according to tracking mode
4. Check if skill has any subpages/children and copy them over
5. Read metadata needed to regenerate the wrapper

Resolution rules

• Version pages are linked from the registry page and named like slug@vN
• Prefer entries marked approved on the registry page when resolving latest-approved
• Compare versions numerically where possible
• If the registry page is ambiguous, do one exact-title workspace search as fallback

Wrapper regeneration

Rebuild the local SKILL.md in the same style as notion-install.

Before overwriting an existing file:

• create SKILL.md.bak

Manifest updates

For each updated skill:

• set installedVersion to the new version
• update pageId if changed
• update updatedAt
• preserve tracking

Do not do these things

• Do not update global skills
• Do not delete unknown manifest entries
• Do not advance pinned skills unless explicitly requested

Implementation steps

1. Detect manifest.
2. Determine whether to update one skill or all.
3. Fetch the configured registry page once.
4. For each selected skill, inspect tracking mode.
5. Resolve the target version from the registry page.
6. Decide whether an update is needed.
7. Regenerate wrapper skill files where needed.
8. Update manifest entries.
9. Report updated, unchanged, and skipped skills.

Success output

At the end, report three groups:

• updated
• unchanged
• skipped

For each updated skill, include old version and new version.

Register these skills, so I can use them globally. You don't need Skill Registry Page ID for this. Register them as per normal workflow you already know.