Refresh skills for current OrgX MCP workflows

.github/workflows/skill-integrity.yml

@@ -0,0 +1,18 @@
+name: Skill Integrity
+
+on:
+  pull_request:
+  push:
+    branches:
+      - main
+
+jobs:
+  validate:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.11"
+      - name: Check OrgX skill tool drift
+        run: python3 scripts/check_skill_tool_drift.py

README.md

@@ -50,6 +50,16 @@ These skills require the [OrgX MCP server](https://mcp.useorgx.com) to be config
 }
 ```
 
+## Verification
+
+Run the repo-level drift check before opening a PR or shipping skill changes:
+
+```bash
+python3 scripts/check_skill_tool_drift.py
+```
+
+The check fails on deprecated OrgX tool names, unknown `mcp__orgx__*` references, and high-value workflow gaps such as spawning without `check_spawn_guard` or opening plan sessions without `complete_plan`.
+
 ## Skill Format
 
 Each skill follows [Anthropic's skill format](https://github.com/anthropics/skills):

bulk-create/SKILL.md

@@ -1,126 +1,63 @@
 ---
 name: Bulk Create
 description: |
-  Create multiple OrgX tasks or milestones from a markdown checklist or bullet list.
-  Automatically detects priorities from keywords and sets up dependencies for nested items.
-  Use when: importing a task list, creating multiple items at once, converting notes to tasks,
-  or batch-creating entities from any list format.
-  Triggers on: "bulk create", "create tasks from list", "import checklist", "batch create".
-  Supports: checkbox lists (- [ ]), bullet lists (- or *), numbered lists (1.).
+  Create multiple OrgX tasks or milestones from a markdown checklist or bullet
+  list. Uses batch creation, ref-based dependency wiring, and current workspace
+  context instead of one-off entity creation loops.
 ---
 
 # Bulk Create
 
-Parse markdown lists and create multiple OrgX entities in batch.
+Parse markdown lists and create multiple OrgX entities in one pass.
 
 ## Supported Formats
 
-```markdown
-# Checkbox lists
+- checkbox lists: `- [ ] item`
+- bullet lists: `- item` or `* item`
+- numbered lists: `1. item`
 
-- [ ] Task one
-- [ ] Task two (urgent)
-- [x] Already done (skipped)
-
-# Bullet lists
-
-- Task one
-- Task two
-  - Subtask (creates dependency)
-
-# Numbered lists
-
-1. First task
-2. Second task (high priority)
-
-# Mixed priorities
-
-- [CRITICAL] Fix security issue
-- [P0] Launch blocker
-- Task with (urgent) keyword
-- (low priority) Nice to have
-```
+Completed checkbox items are skipped by default.
 
 ## Workflow
 
-1. **Parse input** to extract items:
-
-   - Title: main text content
-   - Priority: detected from keywords
-   - Parent: if nested under another item
-   - Checked: skip if already checked [x]
-
-2. **Confirm scope** with user:
-
-   - Entity type: task (default) or milestone
-   - Parent initiative/workstream/milestone
-   - Default priority if not detected
-
-3. **Check context** using `mcp__orgx__list_entities`
-
-   - Verify parent entities exist
-   - Avoid duplicates
-
-4. **Create entities** using `mcp__orgx__create_entity`
-
-   - Process in order (parents before children)
-   - Capture IDs for dependency setup
-
-5. **Set dependencies** using `mcp__orgx__update_entity`
-   - Nested items blocked by their parent
-   - Sequential items can be linked if requested
+1. Bootstrap with `mcp__orgx__orgx_bootstrap`.
+2. Confirm or set workspace via `mcp__orgx__workspace`.
+3. Parse the list into ordered items with priority, nesting, and completion state.
+4. Check the parent initiative, milestone, or workstream with `mcp__orgx__list_entities`.
+5. Build a single `mcp__orgx__batch_create_entities` payload:
+   - use `ref` keys for each created item
+   - use `depends_on` for nested or sequential dependencies
+   - prefer `type=task` unless the user explicitly wants milestones
+6. If a few standalone items are being added to an existing hierarchy, `mcp__orgx__create_task` or `mcp__orgx__create_milestone` is acceptable, but batch create is preferred.
 
 ## Priority Detection
 
-| Keywords                                            | Priority |
-| --------------------------------------------------- | -------- |
-| urgent, critical, ASAP, P0, blocker, [CRITICAL]     | high     |
-| important, P1, high priority                        | high     |
-| normal, P2, medium priority                         | medium   |
-| low priority, P3, nice to have, backlog, eventually | low      |
-
-Default: medium (if no keywords detected)
+| Keywords | Priority |
+| --- | --- |
+| urgent, critical, ASAP, P0, blocker | high |
+| important, P1, high priority | high |
+| normal, P2, medium priority | medium |
+| low priority, P3, backlog, nice to have | low |
 
-## Output Format
+Default priority is `medium`.
 
-```
-✅ Bulk Create Complete
+## Dependency Logic
 
-| # | Title | Priority | ID | Blocked By |
-|---|-------|----------|----|-----------|
-| 1 | Task one | high | task_xxx | - |
-| 2 | Task two | medium | task_yyy | - |
-| 3 | Subtask | medium | task_zzz | task_yyy |
+- Nested items depend on their nearest parent item.
+- Sequential mode is optional; only apply it when the user asks for ordered execution.
+- Prefer `depends_on` in the batch payload over patching dependencies after creation.
 
-📊 Summary:
-  - Created: X entities
-  - Dependencies: Y set
-  - Skipped: Z (already checked or errors)
+## Output Format
 
-❌ Errors (if any):
-  - "Item text": [error message]
 ```
+Bulk create complete
 
-## Dependency Logic
+Created:
+- [id] [title] ([priority])
 
-```
-- Parent task
-  - Child task 1    → blockedBy: [parent]
-  - Child task 2    → blockedBy: [parent]
-    - Grandchild    → blockedBy: [child 2]
-```
-
-For sequential mode (optional):
+Skipped:
+- [title] — already complete
 
+Errors:
+- [title] — [reason]
 ```
-1. First   → blockedBy: []
-2. Second  → blockedBy: [first]
-3. Third   → blockedBy: [second]
-```
-
-## Error Handling
-
-- Continue on individual failures
-- Report all errors at end
-- Never fail entire batch for one item
-- Rollback not supported (items remain if created)

bulk-create/instructions.md

@@ -1,104 +1,23 @@
-You are bulk-creating tasks or milestones from a markdown checklist or bullet list.
+You are bulk-creating OrgX tasks or milestones from a markdown list.
 
-## Input Parsing
+## Required Sequence
 
-Parse the user's input to extract items from:
+1. Call `mcp__orgx__orgx_bootstrap`.
+2. Resolve the active workspace with `mcp__orgx__workspace`.
+3. Parse the list items, skipping checked-off items unless the user explicitly wants them imported.
+4. Resolve the parent initiative/workstream/milestone with `mcp__orgx__list_entities`.
+5. Build one `mcp__orgx__batch_create_entities` payload using:
+   - `ref` for each created item
+   - `depends_on` for nested or sequential relationships
+6. Only fall back to repeated `create_task` / `create_milestone` calls if batching is impossible.
 
-1. **Checkbox lists**: `- [ ] Item title` or `- [x] Item title` (completed)
-2. **Bullet lists**: `- Item title` or `* Item title`
-3. **Numbered lists**: `1. Item title`
+## Parsing Rules
 
-For each item, extract:
+- preserve item order
+- infer priority from title and description
+- carry nested text into the item description
+- do not invent parent entities
 
-- **Title**: The main text of the item
-- **Description**: Any sub-bullets or indented text under the item
-- **Priority**: Detect from keywords in the title or description
+## Output
 
-## Priority Detection
-
-Scan for priority keywords (case-insensitive):
-
-- **high**: "urgent", "critical", "asap", "important", "high priority", "p0", "p1"
-- **medium**: "medium priority", "p2", "normal"
-- **low**: "low priority", "p3", "nice to have", "backlog"
-
-Default to "medium" if no keywords found.
-
-## Nested Items and Dependencies
-
-If items are nested (indented under a parent):
-
-```
-- [ ] Parent task
-  - [ ] Child task 1
-  - [ ] Child task 2
-```
-
-1. Create the parent entity first
-2. Create child entities with `blockedBy` set to parent's ID
-3. Use `mcp__orgx__update_entity` to set dependencies after creation
-
-## Entity Creation Process
-
-1. **Confirm scope**: Ask the user which entity type to create:
-
-   - `task` (default)
-   - `milestone`
-
-2. **Check context**: Use `mcp__orgx__list_entities` to verify:
-
-   - Active initiative (if creating tasks under an initiative)
-   - Active workspace context
-
-3. **Create entities**: For each parsed item, call `mcp__orgx__create_entity` with:
-
-   ```
-   type: "task" or "milestone"
-   title: <extracted title>
-   description: <extracted description or empty>
-   priority: <detected priority>
-   initiative_id: <if applicable>
-   ```
-
-4. **Set dependencies**: For nested items, use `mcp__orgx__update_entity` to set `blockedBy` relationships
-
-## Output Format
-
-After creation, report a summary:
-
-```
-Created X entities:
-
-| ID | Title | Priority | Dependencies |
-|----|-------|----------|--------------|
-| abc123 | Task title | high | - |
-| def456 | Child task | medium | blocked by abc123 |
-
-All entities created successfully under initiative: [initiative name]
-```
-
-## Error Handling
-
-- If an entity fails to create, continue with remaining items
-- Report failures at the end with the specific error
-- Suggest fixes for common issues (missing initiative, invalid priority)
-
-## Example Workflow
-
-User provides:
-
-```
-- [ ] URGENT: Set up CI pipeline
-  - [ ] Configure GitHub Actions
-  - [ ] Add test coverage reporting
-- [ ] Update documentation
-- [ ] Nice to have: Add dark mode support
-```
-
-You should:
-
-1. Parse 4 items (1 parent with 2 children, 2 standalone)
-2. Detect priorities: high, medium, medium, low
-3. Create parent task first, then children with dependencies
-4. Create remaining standalone tasks
-5. Report all created entities with IDs
+Report the created IDs, skipped items, and any per-item failures.

bulk-create/skill.toml

@@ -1,7 +1,7 @@
 name = "bulk-create"
-version = "1.0.0"
-description = "Create multiple tasks or milestones from a markdown checklist or bullet list"
+version = "2.0.0"
+description = "Create multiple tasks or milestones from a markdown checklist or bullet list using batch creation and ref-based dependency wiring"
 entry_instructions = "instructions.md"
-required_tools = ["mcp__orgx__create_entity", "mcp__orgx__list_entities", "mcp__orgx__update_entity"]
+required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__list_entities", "mcp__orgx__batch_create_entities", "mcp__orgx__create_task", "mcp__orgx__create_milestone"]
 required_scopes = []
 resources = []