aiblueprint-cli 1.4.59 → 1.4.60

package/agents-config/skills/{subagent-creator → agents-managers}/references/orchestration-patterns.md

@@ -1,7 +1,7 @@
 # Orchestration Patterns for Multi-Agent Systems
 
 <core_concept>
-Orchestration defines how multiple subagents coordinate to complete complex tasks.
+Orchestration defines how multiple agents coordinate to complete complex tasks.
 
 **Single agent**: Sequential execution within one context.
 **Multi-agent**: Coordination between multiple specialized agents, each with focused expertise.
@@ -61,7 +61,7 @@ Main chat orchestrates:
 </sequential>
 
 <parallel>
-**Parallel/Concurrent pattern**: Multiple specialized subagents perform tasks simultaneously.
+**Parallel/Concurrent pattern**: Multiple specialized agents perform tasks simultaneously.
 
 <characteristics>
 - Agents execute independently and concurrently
@@ -76,7 +76,7 @@ Main chat orchestrates:
 - Processing multiple independent items (review multiple files)
 - Research tasks (gather information from multiple sources)
 
-**Performance data**: Anthropic's research system with 3-5 subagents in parallel achieved 90% time reduction.
+**Performance data**: Anthropic's research system with 3-5 agents in parallel achieved 90% time reduction.
 
 **Example**:
 ```markdown
@@ -372,7 +372,7 @@ Coordinator:
 <implementation_guidance>
 
 
-<coordinator_subagent>
+<coordinator_agent>
 **Example coordinator implementation**:
 
 ```markdown
@@ -418,7 +418,7 @@ If agent fails:
 - Escalate to human if critical
 </error_handling>
 ```
-</coordinator_subagent>
+</coordinator_agent>
 
 <handoff_protocol>
 **Clean handoffs between agents**:

package/agents-config/skills/{subagent-creator/references/writing-subagent-prompts.md → agents-managers/references/writing-agent-prompts.md}

@@ -1,20 +1,20 @@
 <key_insight>
-Subagent prompts should be task-specific, not generic. They define a specialized role with clear focus areas, workflows, and constraints.
+Agent prompts should be task-specific, not generic. They define a specialized role with clear focus areas, workflows, and constraints.
 
-**Critical**: Subagent.md files use pure XML structure (no markdown headings). Like skills and slash commands, this improves parsing and token efficiency.
+**Critical**: Agent.md files use pure XML structure (no markdown headings). Like skills and slash commands, this improves parsing and token efficiency.
 </key_insight>
 
 <xml_structure_rule>
-**Remove ALL markdown headings (##, ###) from subagent body.** Use semantic XML tags instead.
+**Remove ALL markdown headings (##, ###) from agent body.** Use semantic XML tags instead.
 
 Keep markdown formatting WITHIN content (bold, italic, lists, code blocks, links).
 
-See @skills/create-agent-skills/references/use-xml-tags.md for XML structure principles - they apply to subagents too.
+See @skills/create-agent-skills/references/use-xml-tags.md for XML structure principles - they apply to agents too.
 </xml_structure_rule>
 
 <core_principles>
 <principle name="specificity">
-Define exactly what the subagent does and how it approaches tasks.
+Define exactly what the agent does and how it approaches tasks.
 
 ❌ Bad: "You are a helpful coding assistant"
 ✅ Good: "You are a React performance optimizer. Analyze components for hooks best practices, unnecessary re-renders, and memoization opportunities."
@@ -28,7 +28,7 @@ State the role, focus areas, and approach explicitly.
 </principle>
 
 <principle name="constraints">
-Include what the subagent should NOT do. Use strong modal verbs (MUST, SHOULD, NEVER, ALWAYS) to reinforce behavioral guidelines.
+Include what the agent should NOT do. Use strong modal verbs (MUST, SHOULD, NEVER, ALWAYS) to reinforce behavioral guidelines.
 
 Example:
 ```markdown
@@ -45,7 +45,7 @@ Example:
 </core_principles>
 
 <structure_with_xml>
-Use XML tags to structure subagent prompts for clarity:
+Use XML tags to structure agent prompts for clarity:
 
 <example type="security_reviewer">
 ```markdown
@@ -220,7 +220,7 @@ You are a debugging specialist skilled at root cause analysis and systematic pro
 You are a helpful assistant that helps with code.
 ```
 
-This provides no specialization. The subagent won't know what to focus on or how to approach tasks.
+This provides no specialization. The agent won't know what to focus on or how to approach tasks.
 </anti_pattern>
 
 <anti_pattern name="no_workflow">
@@ -229,7 +229,7 @@ This provides no specialization. The subagent won't know what to focus on or how
 You are a code reviewer. Review code for issues.
 ```
 
-Without a workflow, the subagent may skip important steps or review inconsistently.
+Without a workflow, the agent may skip important steps or review inconsistently.
 
 ✅ Good:
 ```markdown
@@ -277,7 +277,7 @@ description: Handles current billing statements and payment processing. Use when
 <anti_pattern name="missing_constraints">
 ❌ Bad: No constraints specified
 
-Without constraints, subagents might:
+Without constraints, agents might:
 - Modify code they shouldn't touch
 - Run dangerous commands
 - Skip important steps
@@ -293,7 +293,7 @@ Without constraints, subagents might:
 </anti_pattern>
 
 <anti_pattern name="requires_user_interaction">
-❌ **Critical**: Subagents cannot interact with users.
+❌ **Critical**: Agents cannot interact with users.
 
 **Bad example:**
 ```markdown
@@ -311,25 +311,25 @@ tools: AskUserQuestion
 ```
 
 **Why this fails:**
-Subagents execute in isolated contexts ("black boxes"). They cannot use AskUserQuestion or any tool requiring user interaction. The user never sees intermediate steps.
+Agents execute in isolated contexts ("black boxes"). They cannot use AskUserQuestion or any tool requiring user interaction. The user never sees intermediate steps.
 
 **Correct approach:**
 ```markdown
 # Main chat handles user interaction
 1. Main chat: Use AskUserQuestion to gather requirements
-2. Launch subagent: Research based on requirements (no user interaction)
+2. Launch agent: Research based on requirements (no user interaction)
 3. Main chat: Present research to user, get confirmation
-4. Launch subagent: Generate code based on confirmed plan
+4. Launch agent: Generate code based on confirmed plan
 5. Main chat: Present results to user
 ```
 
-**Tools that require user interaction (cannot use in subagents):**
+**Tools that require user interaction (cannot use in agents):**
 - AskUserQuestion
 - Any workflow expecting user to respond mid-execution
 - Presenting options and waiting for selection
 
 **Design principle:**
-If your subagent prompt includes "ask user", "present options", or "wait for confirmation", it's designed incorrectly. Move user interaction to main chat.
+If your agent prompt includes "ask user", "present options", or "wait for confirmation", it's designed incorrectly. Move user interaction to main chat.
 </anti_pattern>
 </anti_patterns>
 
@@ -405,8 +405,8 @@ Include examples for complex behaviors:
 ```markdown
 <example>
 Input: [scenario]
-Expected action: [what the subagent should do]
-Output: [what the subagent should produce]
+Expected action: [what the agent should do]
+Output: [what the agent should produce]
 </example>
 ```
 </practice>
@@ -456,9 +456,9 @@ Task is complete when:
 </practice>
 </best_practices>
 
-<testing_subagents>
+<testing_agents>
 <test_checklist>
-1. **Invoke the subagent** with a representative task
+1. **Invoke the agent** with a representative task
 2. **Check if it follows the workflow** specified in the prompt
 3. **Verify output format** matches what you defined
 4. **Test edge cases** - does it handle unusual inputs well?
@@ -467,18 +467,18 @@ Task is complete when:
 </test_checklist>
 
 <common_issues>
-- **Subagent too broad**: Narrow the focus areas
+- **Agent too broad**: Narrow the focus areas
 - **Skipping steps**: Make workflow more explicit
 - **Inconsistent output**: Define output format more clearly
 - **Overstepping bounds**: Add or clarify constraints
 - **Not automatically invoked**: Improve description field with trigger keywords
 </common_issues>
-</testing_subagents>
+</testing_agents>
 
 <quick_reference>
 ```markdown
 ---
-name: subagent-name
+name: agent-name
 description: What it does and when to use it. Include trigger keywords.
 tools: Tool1, Tool2, Tool3
 model: sonnet

package/agents-config/skills/codex-environment/SKILL.md

@@ -1,6 +1,8 @@
 ---
 name: codex-environment
 description: Create, inspect, or repair Codex app Local Environment configuration for worktrees, including .codex/environments/environment.toml, setup and cleanup scripts, worktree up/down scripts, copied env files, isolated databases, and reusable app actions.
+disable-model-invocation: true
+allow_implicit_invocation: false
 ---
 
 # Codex Environment

package/agents-config/skills/commit/SKILL.md

@@ -3,6 +3,8 @@ name: commit
 description: Quick commit and push with minimal, clean messages
 model: haiku
 allowed-tools: Bash(git :*), Bash(npm :*), Bash(pnpm :*)
+disable-model-invocation: true
+allow_implicit_invocation: false
 ---
 
 # Commit

package/agents-config/skills/create-pr/SKILL.md

@@ -3,6 +3,8 @@ name: create-pr
 description: Create and push PR with auto-generated title and description
 model: haiku
 allowed-tools: Bash(git :*), Bash(gh :*)
+disable-model-invocation: true
+allow_implicit_invocation: false
 ---
 
 # Create PR

package/agents-config/skills/environments-manager/SKILL.md

@@ -0,0 +1,271 @@
+---
+name: environments-manager
+description: Set up a per-worktree environment for one or more IDEs (Claude Code, Cursor, Codex) in a single pass. Generates shared scripts/worktree-up.sh, scripts/worktree-down.sh, and scripts/dev.sh, then wires them into each selected IDE's config. Use whenever the user asks to "set up a worktree environment", "configure worktrees", "make this repo worktree-ready", or mentions any of .codex/environments/environment.toml, .cursor/worktrees.json, .claude/settings.json SessionStart, $CODEX_WORKTREE_PATH, $ROOT_WORKTREE_PATH, or $CLAUDE_PROJECT_DIR.
+disable-model-invocation: false
+allow_implicit_invocation: true
+---
+
+# Environments Manager
+
+Set up per-worktree environments so a fresh worktree is instantly ready to run: env files copied, dependencies installed, isolated database created, and common commands one click away. Supports Claude Code, Cursor, and Codex - the **shared scripts are the same on every IDE**; only the config file that points at them differs.
+
+## Interactive Flow
+
+This skill is interactive. Ask the user the two questions below before writing anything - the right setup depends on the project. Use whichever interactive question mechanism the host harness provides. Do not assume answers.
+
+### Step 1: What should happen in a fresh worktree?
+
+Ask the user what the setup script should do, as a multi-select. The first option is the default-on baseline; the rest are additive opt-ins:
+
+| Option | What it adds to `scripts/worktree-up.sh` |
+| :--- | :--- |
+| Copy ignored env files from the source checkout | `cp` of `.env`, `.env.local`, `.env.development.local` (default - almost always wanted) |
+| Install dependencies | `pnpm install` / `bun install` / `npm install` based on lockfile |
+| Create an isolated database for this worktree | Build a unique DB name from the worktree dir, rewrite `DATABASE_URL` in `.env`, run `createdb` + import |
+| Run codegen (Prisma, Drizzle, generated types) | `pnpm prisma:generate` / `bun run db:generate` / etc. |
+
+If the user has project-specific steps (seed data, S3 sync, etc.), ask a follow-up free-form question to capture them.
+
+### Step 2: Which IDEs should be wired up?
+
+Ask a multi-select with options: Claude Code, Cursor, Codex. The user can pick any combination - the shared `scripts/` directory only gets generated once.
+
+### Step 3: Apply each selected IDE
+
+For each selected IDE, read the matching reference file and apply only its linking config. Do not duplicate the script logic - the IDE config just points at `scripts/worktree-up.sh`, `scripts/worktree-down.sh`, and `scripts/dev.sh`.
+
+- Claude Code → load `references/claude.md`
+- Cursor → load `references/cursor.md`
+- Codex → load `references/codex.md`
+
+## Shared Shape
+
+Every project that uses this skill ends up with:
+
+```text
+scripts/
+├── worktree-up.sh        # idempotent setup
+├── worktree-down.sh      # cleanup before worktree teardown
+├── dev.sh                # start dev server on a free port
+└── (project-specific helpers, all *.sh)
+```
+
+Plus one or more IDE config files (see references). The IDE config is thin; all logic lives in `scripts/`.
+
+**Naming convention**: every generated script MUST end in `.sh`. No bare `worktree-up`, no `dev`. IDE configs reference scripts by full filename (`scripts/worktree-up.sh`, not `scripts/worktree-up`). This is enforced in every reference file and example.
+
+## Environment Variable Cascade
+
+Each IDE exposes different variables. The shared scripts accept all of them, in this priority:
+
+```bash
+WORKTREE_PATH="${CODEX_WORKTREE_PATH:-${CURSOR_WORKTREE_PATH:-$(pwd)}}"
+SOURCE_PATH="${CODEX_SOURCE_TREE_PATH:-${ROOT_WORKTREE_PATH:-}}"
+```
+
+| Platform | Worktree path | Source checkout path | Setup trigger |
+| :------- | :----------------------- | :------------------------ | :--- |
+| Codex    | `$CODEX_WORKTREE_PATH`   | `$CODEX_SOURCE_TREE_PATH` | `[setup] script` in TOML, runs once per worktree |
+| Cursor   | `pwd` inside worktree    | `$ROOT_WORKTREE_PATH`     | `setup-worktree-unix` in JSON, runs once per worktree |
+| Claude   | `pwd` inside worktree (the hook wrapper cd's in) | `$CLAUDE_PROJECT_DIR` (source repo, exposed inside the hook); the wrapper re-exports it as `ROOT_WORKTREE_PATH` | `WorktreeCreate` hook, runs once per worktree |
+
+**Important about Claude Code**: do NOT use `SessionStart` for setup - it fires every session. Use the `WorktreeCreate` hook, which fires once when `claude --worktree` creates the worktree. The Claude wrapper script (`scripts/claude-worktree-create.sh`) is responsible for calling `git worktree add` itself, then handing off to `scripts/worktree-up.sh` inside the new worktree with `ROOT_WORKTREE_PATH` set. See [references/claude.md](references/claude.md).
+
+If no env var yields a source checkout, fall back to a project-specific absolute path (e.g. `$HOME/Developer/saas/<repo>`). Ask the user during Step 1 if you cannot infer it.
+
+## `scripts/worktree-up.sh`
+
+Setup must be **idempotent** - reruns are safe. Built from the user's Step 1 selections. Required behavior in order:
+
+1. `set -euo pipefail`.
+2. Resolve `WORKTREE_PATH` and `SOURCE_PATH`.
+3. `cd "$WORKTREE_PATH"`.
+4. If "Copy env files" selected: copy `.env`, `.env.local`, `.env.development.local` only when the source has them and the worktree does not.
+5. If "Install dependencies" selected: detect from lockfile and run the matching install.
+6. If "Isolated database" selected: build a DB name from `basename "$WORKTREE_PATH" | tr '/' '-'`, rewrite only `DATABASE_URL` (and any related vars) in the copied `.env`, create the DB if missing. Provide a reset escape hatch: `<PROJECT>_RESET_DB=1` drops and recreates.
+7. If "Codegen" selected: run the project's codegen command.
+8. Append any free-form project-specific steps from Step 1.
+
+Reference template (adjust based on selections):
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+WORKTREE_PATH="${CODEX_WORKTREE_PATH:-${CURSOR_WORKTREE_PATH:-$(pwd)}}"
+SOURCE_PATH="${CODEX_SOURCE_TREE_PATH:-${ROOT_WORKTREE_PATH:-$HOME/Developer/saas/<repo>}}"
+
+cd "$WORKTREE_PATH"
+
+# Copy ignored env files.
+# NOTE for Claude Code users: .worktreeinclude handles this natively. Prefer it
+# over the cp loop when the project uses Claude's --worktree.
+for f in .env .env.local .env.development.local; do
+  if [[ -f "$SOURCE_PATH/$f" && ! -f "$WORKTREE_PATH/$f" ]]; then
+    cp "$SOURCE_PATH/$f" "$WORKTREE_PATH/$f"
+    echo "copied $f"
+  fi
+done
+
+# Install deps
+if   [[ -f pnpm-lock.yaml ]]; then pnpm install
+elif [[ -f bun.lock || -f bun.lockb ]]; then bun install
+elif [[ -f yarn.lock ]]; then yarn install
+elif [[ -f package-lock.json ]]; then npm install
+fi
+
+# Project-specific DB isolation and codegen go here.
+```
+
+## `scripts/worktree-down.sh`
+
+Cleanup runs before the IDE destroys the worktree.
+
+1. `set -euo pipefail`.
+2. `cd "$WORKTREE_PATH"`.
+3. Read DB names from the worktree `.env`. **Never guess from branch names.**
+4. `dropdb --if-exists` per DB found, against a maintenance database.
+5. Remove copied env files.
+6. If env files or PostgreSQL tools are missing, print one short message and exit 0.
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+WORKTREE_PATH="${CODEX_WORKTREE_PATH:-${CURSOR_WORKTREE_PATH:-$(pwd)}}"
+cd "$WORKTREE_PATH"
+
+if [[ ! -f .env ]]; then
+  echo "no .env in worktree, nothing to clean"
+  exit 0
+fi
+
+db_name=$(grep -E '^DATABASE_URL=' .env | sed -E 's|.*/([^/?]+).*|\1|' | head -n1 || true)
+if [[ -n "${db_name:-}" ]] && command -v dropdb >/dev/null 2>&1; then
+  dropdb --if-exists -d postgres "$db_name" || true
+fi
+
+rm -f .env .env.local .env.development.local
+```
+
+## `scripts/dev.sh`
+
+Pick a free port so multiple worktrees can run in parallel.
+
+```bash
+#!/usr/bin/env bash
+set -euo pipefail
+
+WORKTREE_PATH="${CODEX_WORKTREE_PATH:-${CURSOR_WORKTREE_PATH:-$(pwd)}}"
+cd "$WORKTREE_PATH"
+
+port="${DEV_PORT_START:-3910}"
+while lsof -nP -iTCP:"$port" -sTCP:LISTEN >/dev/null 2>&1; do
+  port=$((port + 1))
+done
+
+echo "Starting app on http://localhost:$port"
+exec pnpm dev -p "$port"  # adjust for the project package manager
+```
+
+## Standard Actions
+
+Every project should expose these four actions through the IDE's own mechanism (see references). Wire them per IDE.
+
+| Action     | Command (typical)                |
+| :--------- | :------------------------------- |
+| Dev        | `scripts/dev.sh`                    |
+| Typecheck  | `pnpm ts` / `bun run typecheck`  |
+| Unit tests | `pnpm test:ci` / `bun test`      |
+| Lint       | `pnpm lint:ci` / `bun run lint`  |
+
+Add `E2E` as an action only if the suite is cheap enough to run interactively.
+
+## Universal Guardrails
+
+- Never commit secrets. Copying ignored env files into a local worktree is fine; logging them is not.
+- Never drop a database whose name was guessed from a branch. Read it from the worktree `.env`.
+- Never put fragile multi-line shell programs inside an IDE config file. Keep all logic in `scripts/`; the IDE config just calls those scripts.
+- Never hardcode a dev port. Pick a free one starting from `${DEV_PORT_START:-3910}`.
+- Setup must be idempotent. Provide a reset escape hatch via env var (`<PROJECT>_RESET_DB=1`).
+- Print DB names and redacted hosts only.
+- The scripts and IDE config must live on the source checkout / main branch, not only the current worktree, or future worktrees will have nothing to copy.
+- **Never import data from a production source.** Any setup step that exports a database/deployment and replays it into the new worktree MUST reject any source ref containing `prod`/`production` and require an explicit override env var (`<PROJECT>_ALLOW_PROD_SOURCE=1`). Even a single mistaken `--replace-all` against the wrong source can nuke a teammate's dev environment or, worse, leak prod data into a feature branch. Default the source to `dev` and validate before each export.
+
+```bash
+assert_dev_source() {
+  case "$1" in
+    prod|prod:*|prod/*|production|production:*|production/*)
+      echo "refusing prod source: $1" >&2; exit 1 ;;
+    *prod*|*production*)
+      [ "${ALLOW_PROD_SOURCE:-0}" = "1" ] || { echo "looks like prod: $1" >&2; exit 1; } ;;
+  esac
+}
+```
+
+- **Hook wrappers must survive a missing `/dev/tty`, a wrong default Node version, and CLI prompts.** See `references/claude.md` → "Hook Robustness" for the five concrete fixes.
+
+## Verification
+
+After generating files:
+
+```bash
+bash -n scripts/worktree-up.sh scripts/worktree-down.sh scripts/dev.sh
+git status --short
+```
+
+If Python 3.11+ is available, validate any generated TOML:
+
+```bash
+python3 - <<'PY'
+import tomllib
+with open(".codex/environments/environment.toml", "rb") as f:
+    tomllib.load(f)
+PY
+```
+
+For JSON configs:
+
+```bash
+python3 -c "import json; json.load(open('.cursor/worktrees.json'))"
+python3 -c "import json; json.load(open('.claude/settings.json'))"
+```
+
+## IDE-Specific Linking
+
+After the shared scripts are written, for each IDE selected in Step 2, load the matching reference file and apply only its linking config:
+
+- **Claude Code** → [references/claude.md](references/claude.md) - `.claude/settings.json` SessionStart hook + custom slash commands as actions.
+- **Cursor** → [references/cursor.md](references/cursor.md) - `.cursor/worktrees.json` setup keys.
+- **Codex** → [references/codex.md](references/codex.md) - `.codex/environments/environment.toml` setup, cleanup, and actions.
+
+If multiple IDEs were selected, generate `scripts/` once and then apply each reference in turn.
+
+## Examples
+
+Working copies of every file this skill generates live under [examples/](examples/). Use them as the source-of-truth shape when writing into a real project. Adapt the project section (package manager, DB name prefix, codegen step) for the target repo.
+
+```text
+examples/
+├── scripts/
+│   ├── worktree-up.sh             # pnpm + Postgres + Prisma reference
+│   ├── worktree-down.sh           # pnpm + Postgres reference
+│   ├── dev.sh                     # free-port dev server reference
+│   ├── claude-worktree-create.sh  # Claude WorktreeCreate hook wrapper
+│   └── claude-worktree-remove.sh  # Claude WorktreeRemove hook wrapper
+├── claude/
+│   ├── .worktreeinclude           # native env-file copy list
+│   ├── settings.json              # WorktreeCreate + WorktreeRemove hooks
+│   └── commands/                  # optional slash-command actions
+│       ├── dev.md
+│       ├── typecheck.md
+│       ├── test.md
+│       └── lint.md
+├── cursor/
+│   └── worktrees.json             # setup-worktree-unix -> scripts/worktree-up.sh
+└── codex/
+    └── environments/
+        └── environment.toml       # setup, cleanup, four actions
+```
+
+Read the relevant example before writing the file into the target project. Do not copy verbatim - the user's Step 1 selections determine which sections of `worktree-up.sh` survive.

package/agents-config/skills/environments-manager/examples/claude/.worktreeinclude

@@ -0,0 +1,3 @@
+.env
+.env.local
+.env.development.local

package/agents-config/skills/environments-manager/examples/claude/commands/dev.md

@@ -0,0 +1,5 @@
+---
+description: Start the dev server on a free port
+---
+
+Run `scripts/dev.sh` from the project root. Stream output until the dev server is listening, then return the URL.

package/agents-config/skills/environments-manager/examples/claude/commands/lint.md

@@ -0,0 +1,5 @@
+---
+description: Run the linter
+---
+
+Run the project's lint command (`pnpm lint:ci`, `bun run lint`, or equivalent). Report any violations.

package/agents-config/skills/environments-manager/examples/claude/commands/test.md

@@ -0,0 +1,5 @@
+---
+description: Run unit tests
+---
+
+Run the project's unit test command (`pnpm test:ci`, `bun test`, or equivalent). Report failures with file:line references.

package/agents-config/skills/environments-manager/examples/claude/commands/typecheck.md

@@ -0,0 +1,5 @@
+---
+description: Typecheck the project
+---
+
+Run the project's typecheck command (`pnpm ts`, `bun run typecheck`, or equivalent based on the lockfile). Report any errors with file:line references.

package/agents-config/skills/environments-manager/examples/claude/settings.json

@@ -0,0 +1,24 @@
+{
+  "hooks": {
+    "WorktreeCreate": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/scripts/claude-worktree-create.sh"
+          }
+        ]
+      }
+    ],
+    "WorktreeRemove": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"$CLAUDE_PROJECT_DIR\"/scripts/claude-worktree-remove.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/agents-config/skills/environments-manager/examples/codex/environments/environment.toml

@@ -0,0 +1,29 @@
+# THIS IS AUTOGENERATED. DO NOT EDIT MANUALLY.
+version = 1
+name = "Project Worktree"
+
+[setup]
+script = "cd \"$CODEX_WORKTREE_PATH\"\nscripts/worktree-up.sh"
+
+[cleanup]
+script = "cd \"$CODEX_WORKTREE_PATH\"\nscripts/worktree-down.sh"
+
+[[actions]]
+name = "Dev"
+icon = "tool"
+command = "scripts/dev.sh"
+
+[[actions]]
+name = "Typecheck"
+icon = "tool"
+command = "pnpm ts"
+
+[[actions]]
+name = "Unit tests"
+icon = "tool"
+command = "pnpm test:ci"
+
+[[actions]]
+name = "Lint"
+icon = "tool"
+command = "pnpm lint:ci"

package/agents-config/skills/environments-manager/examples/cursor/worktrees.json

@@ -0,0 +1,3 @@
+{
+  "setup-worktree-unix": "../scripts/worktree-up.sh"
+}