@goodtek/vibeops 0.7.22 → 1.1.1

package/CHANGELOG.md

@@ -4,6 +4,57 @@ All notable changes to VibeOps are documented here.
 
 ## Unreleased
 
+### Fixed
+
+- Removed dead `task-merge.ts` (local merge no longer used).
+- `task add` checks out integration branch from `origin/<branch>` when only remote exists.
+- `task done` sets Status **Done** only after push/MR succeed; skips duplicate PR when URL exists.
+- Re-init creates missing integration branch on existing repos.
+- `status` shows branch policy and MR/PR URL.
+
+## 1.1.0 - 2026-05-27
+
+### Breaking
+
+- **`task done` no longer merges locally.** It pushes the task branch and opens a **pull/merge request** to the integration branch (`gh` / `glab`). Merge and deploy happen on the host (CI).
+- **`init` requires a git remote** (`origin`) unless `--allow-no-remote` (smoke/CI).
+- **`.vibeops.json` gains a `git` block** (integration/production branches, host). Re-run `vibeops init` on older projects.
+
+### Added
+
+- **Branch policy at init:** GitFlow lite (`develop` + `main`) or trunk (`main` only); `--git-policy`, `--integration-branch`, `--production-branch`.
+- **`task add`** branches from the configured **integration** branch, not arbitrary HEAD.
+- **LLM-generated MR/PR** title and body on `task done`; URL stored in TASK **Git Context**.
+- **`--no-pr`** on `task done` to push only.
+
+## 1.0.0 - 2026-05-27
+
+### Added
+
+- **`vibeops init --clients`**: choose **cursor**, **claude**, **codex** (≥1 required). Installs core + per-client rules/skills (`CLAUDE.md`, `.agents/skills/`, etc.).
+- **Re-init guard**: existing projects prompt before overwriting templates; `docs/tasks/TASK-*.md` are preserved. Use `--yes` for non-interactive re-init.
+- **`vibeops llm`**: `connect`, `status`, `use` for task add/done LLM providers.
+
+### Breaking
+
+- **Four commands only:** `init`, `task add`, `task done`, `status`.
+- **Removed:** `plan`, `start`, `next`, `rollback`, `notion`, `github`, `task generate`, `task check`, `task prompt`, `task pull`, `agent`, and separate `task status`.
+- **Removed Notion:** no `@notionhq/client`, no Notion config in `.vibeops.json`.
+- **Single TASK model:** `TASK-NNN-<slug>.md` only (no `TASK-mvp` workflow).
+- **`task add`:** if a TASK is In Progress, **guide only** and exit 1 — no auto `task done`.
+- **Templates:** no `.vibeops/agents`, workflows, or prompts; slim `docs/project/` set.
+
+### Added
+
+- **`task add`** creates TASK file, task branch, and In Progress status in one step (replaces `start`).
+- **`task done`** LLM assist for Result/Test Result and patches to `05-current-state`, `06-decisions`, `03-architecture`, daily log.
+- **Unified `status`** briefing without Notion/GitHub sections.
+- v3 Cursor rules (3) and optional skills (`plan-task`, `implement-task`).
+
+### Fixed
+
+- Governance stash **pop** after branch switch so new TASK files stay on disk.
+
 ## 0.7.22 - 2026-05-16
 
 ### Fixed

package/README.md

@@ -1,425 +1,96 @@
 # VibeOps
 
-> Workflow rails for Cursor-based vibe coding projects.
+> Minimal CLI rails for TASK-driven vibe coding (Cursor, Claude Code, Codex).
 
 [![npm version](https://img.shields.io/npm/v/@goodtek/vibeops.svg)](https://www.npmjs.com/package/@goodtek/vibeops)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
 
-VibeOps is a local CLI that installs and operates the project structure needed to run Cursor-based vibe coding as reproducible TASKs: `AGENTS.md`, Cursor rules, project docs, TASK files, agents/prompts/workflows, Git lifecycle helpers, and optional Notion dashboard sync.
+VibeOps bootstraps an **agent-friendly repo**, starts numbered **TASK** files on Git branches, and closes them while updating **project memory** in Git. You plan and implement in your chosen agent; the CLI handles files, Git, and short LLM assists.
 
-VibeOps does not write product code for you. Cursor is the builder. VibeOps keeps the workflow on rails.
+## Commands
 
-## What Is VibeOps?
+| Command | Purpose |
+|---------|---------|
+| `vibeops init` | Core docs + agent packs (cursor / claude / codex) |
+| `vibeops task add` | New `TASK-NNN` file + task branch |
+| `vibeops task done` | LLM summary, push branch, open MR/PR (no local merge) |
+| `vibeops status` | Briefing: TASK, Git, LLM, clients |
+| `vibeops llm` | Connect LLM providers (`connect` · `status` · `use`) |
 
-VibeOps is a **local CLI** for turning an idea into a repository that Cursor agents can work on safely and repeatably.
-
-It gives a project:
-
-- `docs/project/*` for product and architecture context.
-- `docs/tasks/TASK-*.md` as the AI execution source of truth.
-- `.cursor/rules/*` and `AGENTS.md` so Cursor knows how to behave.
-- `.vibeops/agents`, `.vibeops/prompts`, `.vibeops/workflows` for reusable agent instructions.
-- MVP workflow: `plan` → `start` → build in Cursor → `done` (Git merge included).
-- Notion metadata sync for a human dashboard.
-
-## Why It Exists
-
-Vibe coding is fast, but chat history is a weak source of truth. Without a durable workflow, agents repeat work, drift outside scope, lose decision history, and leave teammates without a dashboard. VibeOps moves the durable context into Git files and uses CLI commands to keep each TASK bounded.
-
-## Core Philosophy
-
-- **VibeOps = workflow rail**: it structures the work, validates state, and prints prompts.
-- **Cursor = builder**: Cursor reads the docs/TASKs and writes application code.
-- **Git `docs/tasks` = AI execution source of truth**: TASK markdown beats chat memory.
-- **Notion = human dashboard**: Notion shows metadata and progress, not canonical task bodies.
-
-| What | Source of truth |
-| --- | --- |
-| AI execution input | Git `docs/tasks/*.md` |
-| Project design/status | Git `docs/project/*.md` |
-| Change and rollback evidence | Git commits/branches |
-| Human dashboard | Notion Projects/Tasks DB |
-| Not a source of truth | Cursor chat, Slack, memory |
-
-## Installation
-
-VibeOps requires Node.js 20+.
+## Init
 
 ```bash
-npm install -g @goodtek/vibeops
-vibeops --help
-```
-
-The published package is `@goodtek/vibeops`. The installed CLI command is `vibeops`.
-
-For local development from this repository:
-
-```bash
-pnpm install
-pnpm build
-node dist/cli.js --help
-```
-
-## Quick Start
-
-```bash
-# 1. Install VibeOps workflow files into the current project.
-# Interactive mode can also initialize Git and create the first commit.
+# Interactive: pick agents (≥1), then Git
 vibeops init
 
-# Non-interactive Git bootstrap:
-vibeops init --git --initial-commit
-
-# 2. LLM planning → brief + TASK-mvp + mvp-build.md (OpenAI, Codex OAuth, or Cursor agent CLI).
-vibeops plan
+# Non-interactive (GitFlow: develop + main, origin required unless CI)
+vibeops init --clients cursor,claude,codex --git --initial-commit --git-policy gitflow
 
-# 3. Task branch for the single MVP TASK.
-vibeops start
-
-# 4. Drag .vibeops/generated/mvp-build.md into a new Cursor chat and implement.
-
-# 5. Finish: verify Result/Test Result, merge to main, delete task branch.
-vibeops done
-
-# 6. Optional: interactive nudge
-vibeops next
-
-# 7. Optional Notion dashboard sync.
-vibeops notion init
-vibeops notion test
-vibeops notion sync --dry-run
+# Re-init templates on an existing project
+vibeops init --clients cursor --yes
 ```
 
-## Quick Tutorial: Acme Automator
+| Pack | Installed |
+|------|-----------|
+| **core** (always) | `AGENTS.md`, `docs/tasks`, `docs/project`, `docs/logs` |
+| **cursor** | `.cursor/rules/`, `.cursor/skills/` |
+| **claude** | `CLAUDE.md`, `.claude/skills/` |
+| **codex** | `.agents/skills/` |
 
-Suppose the idea is: “Build **Acme Automator**, a SaaS that schedules and runs browser automation jobs for marketing teams.”
+Re-init **overwrites** templates (rules, skills, doc stubs). **`docs/tasks/TASK-*.md` are kept.**
 
-```bash
-mkdir acme-automator
-cd acme-automator
-
-vibeops init --name "Acme Automator" --git --initial-commit
-vibeops plan --idea "Acme Automator: schedule and run browser automation jobs for marketing teams"
-vibeops start
-# Drag .vibeops/generated/mvp-build.md into Cursor and build the MVP.
-vibeops done
-```
-
-If a Notion dashboard is enabled:
+## Workflow
 
 ```bash
-vibeops notion init
-vibeops notion test
-vibeops notion sync --dry-run
-vibeops notion sync
-```
+vibeops init --clients cursor --git --initial-commit
 
-## Full Command Flow
+vibeops task add
+# Plan / build using your agent and the current TASK file
 
-```text
-vibeops
-├─ init
-├─ plan
-├─ start [mvp]
-├─ done [mvp]
-├─ next
-├─ status
-├─ rollback [mvp]
-├─ notion { init | test | sync }
-└─ github { status | init }
+vibeops task done
+vibeops status
 ```
 
-Run any command with `--help` for the option details.
-
-## Features
-
-### Project Bootstrapper
-
-`vibeops init` installs a project operating system: `AGENTS.md`, `.cursor/rules`, `docs/project`, `docs/tasks`, `.vibeops/agents`, `.vibeops/prompts`, `.vibeops/workflows`, `.vibeops.json`, and `.vibeops.env.example`. It is idempotent by default and only overwrites when `--force` is used.
-
-### Interactive Planner
-
-`vibeops plan` (requires `.vibeops.json`) runs an LLM discovery session (OpenAI, Codex OAuth, or Cursor Agent CLI), then writes:
-
-- `.vibeops/brief/project-brief.md`
-- `docs/tasks/TASK-mvp-*.md`
-- `.vibeops/generated/mvp-build.md` — **drag this file into Cursor** to implement the MVP
-
-Use `--from` to regenerate MVP artifacts from an edited brief. Use `--non-interactive` in CI (placeholders only).
-
-### MVP Git Rails
-
-- `vibeops start` — task branch + Git Context on **TASK-mvp**
-- `vibeops done` — verify Result/Test Result, mark Done, merge, **Notion sync** (when enabled), post-MVP dirty-tree cleanup, next-task LLM suggestion
-- `vibeops next` — interactive guide (start → build → finish)
-- `vibeops rollback` — advisory by default; `--confirm` / `--confirm-destructive` to execute
-
-### Notion Dashboard Sync
-
-`notion init/test/sync` pushes project + TASK **metadata** only (not markdown bodies).
-
-## Runner Modes
-
-- **Prompt mode (default)**: VibeOps prints Cursor-ready prompts. Cursor executes the code changes.
-- VibeOps does not call LLM APIs and does not invoke Cursor CLI directly today; it works as a workflow rail around the human + Cursor loop.
-
-## Notion Setup
-
-Notion is optional. If enabled:
-
-- `NOTION_TOKEN` is the **only** environment variable VibeOps reads. It lives in `.vibeops.env` (gitignored) or in `process.env`.
-- Target IDs live in `.vibeops.json`, not in `.vibeops.env`.
-- `projectsTargetId` / `tasksTargetId` are preferred resolved **data_source** IDs.
-- `projectsDatabaseId` / `tasksDatabaseId` remain legacy/container fallbacks.
-- `notion init` uses data_source-first discovery. If no data sources are found, it can search accessible pages, scan 1-depth inline database blocks, then resolve child databases to data source IDs.
-- Legacy `NOTION_API_KEY` / `NOTION_PROJECT_DB` / `NOTION_TASK_DB` environment variables are no longer used. The `.vibeops.env.example` that `vibeops init` writes contains only `NOTION_TOKEN=`.
-
-Required Projects DB properties:
-
-| Property | Type |
-| --- | --- |
-| `Name` | `title` |
-| `Project ID` | `rich_text` |
-| `Status` | `status` |
-| `Local Path` | `rich_text` |
-| `Git Repo` | `rich_text` or `url` |
-| `Current Phase` | `select` |
-| `Docs Path` | `rich_text` |
-| `Summary` | `rich_text` |
-
-Required Tasks DB properties:
-
-| Property | Type |
-| --- | --- |
-| `Name` | `title` |
-| `Task ID` | `rich_text` |
-| `Project ID` | `rich_text` |
-| `Status` | `status` |
-| `Priority` | `select` |
-| `MVP Phase` | `select` |
-| `Git Branch` | `rich_text` |
-| `Docs Path` | `rich_text` |
-| `Summary` | `rich_text` |
-| `Result Summary` | `rich_text` |
-
-> `MVP Phase` here is a Notion property name kept for compatibility with existing dashboards. It is a free-form label column and is not an internal release-phase tag.
-
-Required Status options:
-
-- Projects DB: `Building`, `Planning`, `Paused`, `Done`, `Archived`
-- Tasks DB: `Planned`, `In Progress`, `Review`, `Done`, `Blocked`
+If a TASK is **In Progress**, `task add` exits with a guide — it does not auto-run `task done`.
 
-VibeOps validates these options in `notion test` and `notion sync --dry-run`, but it never creates or mutates Notion schema.
+## LLM (optional)
 
-## GitHub Setup
-
-GitHub integration runs on top of the GitHub CLI (`gh`). VibeOps never stores `GITHUB_TOKEN` — authentication is owned by `gh auth login`.
-
-1. Install `gh`:
-
-   ```bash
-   brew install gh
-   # or follow https://cli.github.com/
-   ```
-
-2. Authenticate:
-
-   ```bash
-   gh auth login
-   ```
-
-3. Probe state:
-
-   ```bash
-   vibeops github status
-   ```
-
-4. Connect or create a repo interactively:
-
-   ```bash
-   # plan only — no gh / git / file mutation
-   vibeops github init --dry-run
-
-   # plan a new public repo
-   vibeops github init --dry-run --owner <user> --repo <name> --public
-
-   # connect to an existing repo by slug or URL
-   vibeops github init --dry-run --connect <owner>/<repo>
-   vibeops github init --dry-run --connect https://github.com/<owner>/<repo>.git
-   vibeops github init --dry-run --connect git@github.com:<owner>/<repo>.git
-   ```
-
-`vibeops github init` applies four things in sequence:
-
-- (optional) `gh repo create <owner>/<repo> --public|--private --source=. --remote=origin` for new repos.
-- `git remote add origin <url>` (or `git remote set-url`) for the `--connect` path. Existing remotes are never silently overwritten — VibeOps asks first and defaults to No.
-- Updates `package.json` `repository.url`, `homepage`, `bugs.url` (skip with `--no-package-update`).
-- Writes the `github` section of `.vibeops.json`: `enabled`, `mode = "gh-cli"`, `owner`, `repo`, `remote`, `visibility`, `url`.
-
-VibeOps never runs `git push`. Push your branch manually with `git push -u <remote> <branch>`.
-
-## Init Git Bootstrap
-
-`vibeops init` can optionally do the first local Git setup while installing the workflow files. In interactive mode it asks:
-
-- Initialize Git repository?
-- Use `main` as default branch?
-- Create initial commit?
-- Initial commit message
-
-For non-interactive setup:
+For **`task add`** / **`task done`** only (not for coding in the IDE):
 
 ```bash
-vibeops init --git --initial-commit
-vibeops init --git --no-initial-commit
-vibeops init --git --default-branch main --commit-message "chore: initialize vibeops project"
-```
-
-Safety rules:
-
-- Existing Git repositories skip `git init`.
-- Existing repositories with commits skip the initial commit path.
-- `--dry-run` runs no Git commands.
-- VibeOps never pushes and never changes remotes during `init`.
-- Before the initial commit, VibeOps prints how many files will be included.
-
-Before the first commit, `vibeops status` distinguishes an unborn branch from a detached HEAD:
-
-```text
-Git
-  branch  main (unborn, no commits yet)
-  status  dirty
-  hint    create the first commit or run `vibeops init --git --initial-commit`
-```
-
-## Status Output
-
-`vibeops status` summarizes the local project surface only. It never calls the Notion API and never spawns `gh`. The Notion section reads from `.vibeops.env` / `process.env` (for `NOTION_TOKEN` presence) and `.vibeops.json` (for target IDs). The GitHub section reads from `.vibeops.json`. The Package section reads from `package.json`.
-
-Example output for a fully-configured project:
-
-```text
-Git
-  branch  main
-  status  clean
-
-Notion
-  enabled          yes
-  token            configured (.vibeops.env)
-  projects target  configured
-  tasks target     configured
-  hint             run `vibeops notion test`
-
-GitHub
-  enabled     yes
-  mode        gh-cli
-  owner/repo  goodtekxyz/vibeops
-  remote      origin
-  url         https://github.com/goodtekxyz/vibeops
-
-Package
-  name     @goodtek/vibeops
-  version  0.2.0
-  bin      vibeops
+vibeops llm connect
+vibeops llm use auto   # auto | codex-oauth | cursor-agent | openai
 ```
 
-For a fresh project that has not been wired to Notion or GitHub yet:
-
-```text
-Notion
-  enabled          no
-  token            missing
-  projects target  missing
-  tasks target     missing
-  hint             run `vibeops notion init`
-
-GitHub
-  enabled  no
-  hint     run `vibeops github init`
-```
-
-If the project has no `package.json`, the Package section degrades gracefully:
-
-```text
-Package
-  package.json missing
-```
-
-`vibeops status --json` exposes the same surface programmatically, including `notion.tokenSource`, `notion.hasProjectsTarget`, `notion.hasTasksTarget`, the entire `github` object, and the entire `package` object. Legacy environment variables (`NOTION_API_KEY`, `NOTION_PROJECT_DB`, `NOTION_TASK_DB`) are no longer surfaced — VibeOps only uses `NOTION_TOKEN`.
-
-## Git Rollback Safety
-
-- `task start` records base branch, base commit, and task branch in task state.
-- `task check` is read-only and reports working tree + committed changes.
-- `task done` validates TASK Result/Test Result and moves to Review by default.
-- `task rollback` is advisory unless explicit confirmation flags are supplied.
-
-## Agent Workflow
+## Installation
 
-Agents are Markdown files under `.vibeops/agents`. Use:
+Node.js 20+.
 
 ```bash
-vibeops agent list
-vibeops agent show builder
-vibeops task prompt TASK-001 --agent builder
-```
-
-The default project template includes agents such as `orchestrator`, `planner`, `architect`, `builder`, `reviewer`, `tester`, `docs`, and `recovery`.
-
-## Packaging / npm Usage
-
-This package exposes the `vibeops` binary:
-
-```json
-{
-  "bin": {
-    "vibeops": "dist/cli.js"
-  }
-}
+npm install -g @goodtek/vibeops
 ```
 
-Package contents are limited by `package.json#files` to built output, templates, and top-level docs/license files. `dist/` is generated by `pnpm build` / `prepack` and is not committed.
-
-Useful maintainer commands:
+Development:
 
 ```bash
-pnpm typecheck
-pnpm build
-pnpm smoke
-pnpm pack
-pnpm publish --dry-run --access public --no-git-checks
+pnpm install && pnpm build && pnpm smoke
 ```
 
-Actual `npm publish` is a manual release action and is not performed by this repository workflow.
-
-## Security Notes
-
-- `.vibeops.env` is gitignored and must contain secrets such as `NOTION_TOKEN`.
-- VibeOps masks tokens in CLI output.
-- Notion test/debug output is token-safe.
-- `notion sync --dry-run` performs no mutation.
-- `task pull --dry-run` performs no file or Notion mutation.
-- Notion page bodies are never synced.
-- Git destructive rollback paths require explicit confirmation.
-- `github init` uses `gh` CLI auth — VibeOps never stores `GITHUB_TOKEN`.
-- `github init --dry-run` runs zero `gh` / `git remote` / file mutations and produces only a plan.
-
-## Support
+## Flags (common)
 
-- Bugs, setup issues, and usage questions: [support@goodtek.xyz](mailto:support@goodtek.xyz)
-- Collaboration and feedback: [hello@goodtek.xyz](mailto:hello@goodtek.xyz)
-- Issue tracker: [github.com/goodtekxyz/vibeops/issues](https://github.com/goodtekxyz/vibeops/issues)
+- **`init`**: `--clients`, `--yes`, `--dry-run`, `--force`, `--git`, `--initial-commit`, `--git-policy gitflow|trunk`, `--integration-branch`, `--production-branch`, `--allow-no-remote`, `--cwd`
+- **`task add`**: `--dry-run`, `--non-interactive --idea "…"`
+- **`task done`**: `--dry-run`, `--no-pr` (push only)
+- **`status`**: `--json`
 
-## Documentation
+## Git
 
-- [`AGENTS.md`](AGENTS.md) — agent operating guide.
-- [`docs/project/00-overview.md`](docs/project/00-overview.md) — vision and scope.
-- [`docs/project/01-architecture.md`](docs/project/01-architecture.md) — CLI / config / data flow.
-- [`docs/project/03-current-state.md`](docs/project/03-current-state.md) — current implementation state.
-- [`docs/project/04-decisions.md`](docs/project/04-decisions.md) — decisions already made.
-- [`docs/project/05-backlog.md`](docs/project/05-backlog.md) — task order.
-- [`docs/tasks/`](docs/tasks/) — TASK files used by Cursor.
+- **Init** records branch policy in `.vibeops.json` (`integrationBranch`, `productionBranch`, `host`).
+- **`task add`**: branch `task/<slug>` from the **integration** branch (e.g. `develop`).
+- **`task done`**: commit if needed → `git push` → `gh pr create` / `glab mr create` (LLM title/body). **You merge on GitHub/GitLab**; CI deploys.
+- Commit messages: `feat(task-nnn): …`
+- No force-push to shared branches
 
 ## License
 
-MIT © VibeOps contributors
+MIT

package/dist/bootstrap/installer.js

@@ -1,29 +1,19 @@
+import { readdir } from "node:fs/promises";
 import { join } from "node:path";
-import { ensureDir, pathExists, readText, readTextOrNull, writeText } from "../lib/filesystem.js";
+import { ensureDir, pathExists, readText, readTextOrNull, writeText, } from "../lib/filesystem.js";
+import { CLIENT_SKILL_ROOT } from "../lib/init-clients.js";
 import { dim, green, log, yellow } from "../lib/logger.js";
-import { projectPaths, VIBEOPS_ENV_FILE } from "../lib/paths.js";
-import { loadManifest, resolveDestination } from "./manifest.js";
+import { projectPaths, TEMPLATES_ROOT, VIBEOPS_ENV_FILE } from "../lib/paths.js";
+import { loadInstallManifest, resolveDestination } from "./manifest.js";
 import { applySubstitutions, buildSubstitutions, isTextPath, } from "./substitute.js";
 import { configToJson } from "../lib/config.js";
 function envExampleContents() {
-    // Modern VibeOps reads exactly one Notion secret: NOTION_TOKEN.
-    // Notion Projects / Tasks target IDs live in `.vibeops.json` under
-    // `notion.projectsTargetId` / `notion.tasksTargetId` (configured by
-    // `vibeops notion init`), so they are NOT environment variables.
-    //
-    // We intentionally do NOT seed GITHUB_TOKEN / OPENAI_* here:
-    //   - GitHub integration uses `gh` CLI auth.
-    //   - VibeOps' default runner is prompt mode and does not call LLM APIs.
     return [
-        "# VibeOps · environment example",
-        "# Copy this file to .vibeops.env and fill in the value.",
-        "# Never commit .vibeops.env — it is added to .gitignore by `vibeops init`.",
+        "# VibeOps · optional environment",
+        "# Copy to .vibeops.env (gitignored). Never commit secrets.",
         "#",
-        "# NOTION_TOKEN is the only secret VibeOps reads. Get it from",
-        "# https://www.notion.so/profile/integrations after creating an internal",
-        "# integration and sharing the target databases with it.",
-        "",
-        "NOTION_TOKEN=",
+        "# LLM for task add / task done (optional — Codex OAuth and Cursor Agent CLI also work):",
+        "# OPENAI_API_KEY=",
         "",
     ].join("\n");
 }
@@ -86,19 +76,51 @@ async function ensureGitignoreEntry(projectRoot, dryRun) {
         relativePath: ".gitignore",
     };
 }
+async function listSharedSkillNames() {
+    const sharedRoot = join(TEMPLATES_ROOT, "skills-shared");
+    if (!(await pathExists(sharedRoot)))
+        return [];
+    const entries = await readdir(sharedRoot, { withFileTypes: true });
+    return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+}
+async function installSharedSkills(options, subs) {
+    const outcomes = [];
+    const skillNames = await listSharedSkillNames();
+    const sharedRoot = join(TEMPLATES_ROOT, "skills-shared");
+    for (const client of options.clients) {
+        const skillRoot = CLIENT_SKILL_ROOT[client];
+        for (const skillName of skillNames) {
+            const sourceAbs = join(sharedRoot, skillName, "SKILL.md");
+            if (!(await pathExists(sourceAbs)))
+                continue;
+            const relativePath = join(skillRoot, skillName, "SKILL.md");
+            const dest = join(options.projectRoot, relativePath);
+            const entry = { relativePath, sourceAbs };
+            if (!options.dryRun) {
+                await ensureDir(join(dest, ".."));
+            }
+            outcomes.push(await copyOne(entry, dest, subs, options));
+        }
+    }
+    return outcomes;
+}
 export async function install(options) {
     const paths = projectPaths(options.projectRoot);
     const subs = buildSubstitutions(options.config);
     if (!options.dryRun) {
         await ensureDir(paths.root);
     }
-    const manifest = await loadManifest();
+    const manifest = await loadInstallManifest(options.clients);
     const outcomes = [];
     for (const entry of manifest) {
         const dest = resolveDestination(entry, paths.root);
+        if (!options.dryRun) {
+            await ensureDir(join(dest, ".."));
+        }
         const outcome = await copyOne(entry, dest, subs, options);
         outcomes.push(outcome);
     }
+    outcomes.push(...(await installSharedSkills(options, subs)));
     const configOutcome = await writeBlobIfNeeded(paths.config, ".vibeops.json", configToJson(options.config), options);
     outcomes.push(configOutcome);
     const envExampleOutcome = await writeBlobIfNeeded(paths.envExample, ".vibeops.env.example", envExampleContents(), options);

package/dist/bootstrap/manifest.js

@@ -1,6 +1,29 @@
 import { join, relative } from "node:path";
 import { walk } from "../lib/filesystem.js";
+import { pathExists } from "../lib/filesystem.js";
 import { TEMPLATES_ROOT } from "../lib/paths.js";
+async function loadManifestFromDirectory(rootDir) {
+    if (!(await pathExists(rootDir)))
+        return [];
+    const files = await walk(rootDir);
+    return files.map((abs) => ({
+        relativePath: relative(rootDir, abs),
+        sourceAbs: abs,
+    }));
+}
+/** Core tree + selected client packs (not shared skills — those are copied separately). */
+export async function loadInstallManifest(clients) {
+    const entries = [];
+    entries.push(...(await loadManifestFromDirectory(join(TEMPLATES_ROOT, "core"))));
+    for (const id of clients) {
+        entries.push(...(await loadManifestFromDirectory(join(TEMPLATES_ROOT, "clients", id))));
+    }
+    return entries.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+}
+export function resolveDestination(entry, projectRoot) {
+    return join(projectRoot, entry.relativePath);
+}
+/** @deprecated Use loadInstallManifest — walks entire templates/ (legacy). */
 export async function loadManifest() {
     const files = await walk(TEMPLATES_ROOT);
     return files
@@ -10,6 +33,3 @@ export async function loadManifest() {
     }))
         .sort((a, b) => a.relativePath.localeCompare(b.relativePath));
 }
-export function resolveDestination(entry, projectRoot) {
-    return join(projectRoot, entry.relativePath);
-}