diff --git a/README.md b/README.md index da28a62..f946d01 100644 --- a/README.md +++ b/README.md @@ -58,7 +58,7 @@ Run the repo-level drift check before opening a PR or shipping skill changes: 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`. +The check fails on deprecated OrgX tool names, unknown `mcp__orgx__*` references, and high-value workflow gaps such as spawning without `orgx_spawn` or opening plan sessions without `orgx_plan`. ## Skill Format diff --git a/bulk-create/SKILL.md b/bulk-create/SKILL.md index 52cd228..015b009 100644 --- a/bulk-create/SKILL.md +++ b/bulk-create/SKILL.md @@ -22,14 +22,14 @@ Completed checkbox items are skipped by default. ## Workflow 1. Bootstrap with `mcp__orgx__orgx_bootstrap`. -2. Confirm or set workspace via `mcp__orgx__workspace`. +2. Confirm or set workspace via `mcp__orgx__orgx_bootstrap`. 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: +4. Check the parent initiative, milestone, or workstream with `mcp__orgx__orgx_search`. +5. Build a single `mcp__orgx__orgx_write` 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. +6. If a few standalone items are being added to an existing hierarchy, `mcp__orgx__orgx_write` or `mcp__orgx__orgx_write` is acceptable, but batch create is preferred. ## Priority Detection diff --git a/bulk-create/instructions.md b/bulk-create/instructions.md index e3634c3..73f6da1 100644 --- a/bulk-create/instructions.md +++ b/bulk-create/instructions.md @@ -3,13 +3,13 @@ You are bulk-creating OrgX tasks or milestones from a markdown list. ## Required Sequence 1. Call `mcp__orgx__orgx_bootstrap`. -2. Resolve the active workspace with `mcp__orgx__workspace`. +2. Resolve the active workspace with `mcp__orgx__orgx_bootstrap`. 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: +4. Resolve the parent initiative/workstream/milestone with `mcp__orgx__orgx_search`. +5. Build one `mcp__orgx__orgx_write` 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. +6. Only fall back to repeated `orgx_write` / `orgx_write` calls if batching is impossible. ## Parsing Rules diff --git a/bulk-create/skill.toml b/bulk-create/skill.toml index e80b5af..dfae50e 100644 --- a/bulk-create/skill.toml +++ b/bulk-create/skill.toml @@ -2,6 +2,6 @@ name = "bulk-create" 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__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__list_entities", "mcp__orgx__batch_create_entities", "mcp__orgx__create_task", "mcp__orgx__create_milestone"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_search", "mcp__orgx__orgx_write", "mcp__orgx__orgx_write", "mcp__orgx__orgx_write"] required_scopes = [] resources = [] diff --git a/design-agent/SKILL.md b/design-agent/SKILL.md index 46e002f..981c7fc 100644 --- a/design-agent/SKILL.md +++ b/design-agent/SKILL.md @@ -10,17 +10,17 @@ description: | ## 1. Quick Start -1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__workspace`. -2. Confirm the artifact or decision type and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__get_task_with_context`; otherwise map neighboring work with `mcp__orgx__list_entities`. -3. Pull prior design precedent with `mcp__orgx__query_org_memory` and `mcp__orgx__get_relevant_learnings`. -4. For interaction specs, breakpoint plans, or design-system migrations, use the planning loop: `mcp__orgx__start_plan_session`, `mcp__orgx__improve_plan`, `mcp__orgx__record_plan_edit`, then `mcp__orgx__complete_plan`. +1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__orgx_bootstrap`. +2. Confirm the artifact or decision type and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__orgx_inspect`; otherwise map neighboring work with `mcp__orgx__orgx_search`. +3. Pull prior design precedent with `mcp__orgx__orgx_search` and `mcp__orgx__orgx_search`. +4. For interaction specs, breakpoint plans, or design-system migrations, use the planning loop: `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, then `mcp__orgx__orgx_plan`. 5. Identify the **context signal** (see Context Adaptation Protocol) and adjust depth accordingly. 6. Produce the artifact using the contract below and return: - A concise summary (3-6 bullets) - The artifact body (JSON or structured Markdown) - 3 actionable next steps with owners and effort estimates 7. Run the precision loop before delivery. Every artifact ships validator-clean. -8. Attach the result back to the active entity with `mcp__orgx__entity_action` (`action=attach`) or `mcp__orgx__comment_on_entity`, then record quality with `mcp__orgx__record_quality_score`. +8. Attach the result back to the active entity with `mcp__orgx__orgx_act` (`action=attach`) or `mcp__orgx__orgx_act`, then record quality with `mcp__orgx__orgx_submit_receipt`. Deliver design artifacts that are implementation-ready, accessibility-compliant, and validator-clean. @@ -119,15 +119,15 @@ If inputs are incomplete, declare assumptions explicitly at the top of the artif ## 6. Operating Workflow -1. **Bootstrap**: Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__workspace`. -2. **Scope**: Confirm the artifact type and audience. If task-bound, load `mcp__orgx__get_task_with_context`. Identify the context signal from the table above. +1. **Bootstrap**: Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__orgx_bootstrap`. +2. **Scope**: Confirm the artifact type and audience. If task-bound, load `mcp__orgx__orgx_inspect`. Identify the context signal from the table above. 3. **Gather evidence**: - - Query existing OrgX artifacts with `mcp__orgx__list_entities` - - Pull prior standards and decisions with `mcp__orgx__query_org_memory` - - Pull prior learnings with `mcp__orgx__get_relevant_learnings` + - Query existing OrgX artifacts with `mcp__orgx__orgx_search` + - Pull prior standards and decisions with `mcp__orgx__orgx_search` + - Pull prior learnings with `mcp__orgx__orgx_search` - Pull Figma context with `mcp__figma__*` when available - Review related artifacts from Engineering and Product agents for constraints -4. **Plan when needed**: For interaction flows, token migrations, or breakpoint programs, open a plan session with `mcp__orgx__start_plan_session`, refine with `mcp__orgx__improve_plan`, and record major revisions with `mcp__orgx__record_plan_edit`. +4. **Plan when needed**: For interaction flows, token migrations, or breakpoint programs, open a plan session with `mcp__orgx__orgx_plan`, refine with `mcp__orgx__orgx_plan`, and record major revisions with `mcp__orgx__orgx_plan`. 5. **Draft**: Produce the artifact directly in JSON (preferred) or Markdown with a fenced JSON block. 6. **Self-review**: Run the Precision Loop (Section 12) against the draft. 7. **Validate**: @@ -137,13 +137,13 @@ python3 scripts/validate_design.py --type ``` 8. **Fix and re-validate**: Resolve every failed gate. Re-run validator until all gates pass. -9. **Publish**: Save with `mcp__orgx__create_entity` and link related entities. +9. **Publish**: Save with `mcp__orgx__orgx_write` and link related entities. 10. **Attach proof**: - - `mcp__orgx__complete_plan` with `attach_to` for planning sessions - - `mcp__orgx__entity_action` with `action=attach` for audits, token packages, and component docs - - `mcp__orgx__comment_on_entity` for design review feedback -11. **Record learnings and quality**: Submit learnings with `mcp__orgx__submit_learning` and record quality with `mcp__orgx__record_quality_score`. -12. **Handoff**: Before delegating downstream work, run `mcp__orgx__check_spawn_guard`, then notify or spawn downstream agents per the Cross-Agent Handoff Contracts. + - `mcp__orgx__orgx_plan` with `attach_to` for planning sessions + - `mcp__orgx__orgx_act` with `action=attach` for audits, token packages, and component docs + - `mcp__orgx__orgx_act` for design review feedback +11. **Record learnings and quality**: Submit learnings with `mcp__orgx__orgx_submit_receipt` and record quality with `mcp__orgx__orgx_submit_receipt`. +12. **Handoff**: Before delegating downstream work, run `mcp__orgx__orgx_spawn`, then notify or spawn downstream agents per the Cross-Agent Handoff Contracts. ## 7. Artifact Contracts @@ -752,7 +752,7 @@ The design agent improves over time by recording learnings and consuming them on ### Recording learnings: -After every artifact delivery, submit a learning to `mcp__orgx__submit_learning` with: +After every artifact delivery, submit a learning to `mcp__orgx__orgx_submit_receipt` with: - `category`: `design_pattern` | `accessibility_fix` | `token_decision` | `research_finding` | `motion_pattern` - `observation`: What was decided and why @@ -762,7 +762,7 @@ After every artifact delivery, submit a learning to `mcp__orgx__submit_learning` ### Consuming learnings: -At the start of every artifact, query `mcp__orgx__query_org_memory` with: +At the start of every artifact, query `mcp__orgx__orgx_search` with: - The component or flow name - The artifact type @@ -784,21 +784,21 @@ Apply relevant prior learnings. Reference them explicitly (e.g., "Per learning L ### Primary: - `mcp__orgx__orgx_bootstrap` — initialize OrgX session scope and recommended workflow -- `mcp__orgx__workspace` — resolve workspace scope before review or publication -- `mcp__orgx__get_task_with_context` — hydrate task-bound context, attachments, and plan sessions -- `mcp__orgx__list_entities` — Query existing design artifacts and related work -- `mcp__orgx__query_org_memory` — Pull prior design decisions and learnings -- `mcp__orgx__get_relevant_learnings` — retrieve design-specific learnings before drafting -- `mcp__orgx__start_plan_session` — open tracked design planning sessions -- `mcp__orgx__improve_plan` — refine interaction or system plans -- `mcp__orgx__record_plan_edit` — capture major planning revisions -- `mcp__orgx__complete_plan` — persist and attach finalized design plans -- `mcp__orgx__create_entity` — Publish completed artifacts -- `mcp__orgx__entity_action` — attach evidence and update entity state -- `mcp__orgx__submit_learning` — Record design learnings for the flywheel -- `mcp__orgx__comment_on_entity` — Add design review comments to engineering work -- `mcp__orgx__record_quality_score` — score artifact quality for calibration -- `mcp__orgx__check_spawn_guard` — verify delegation is allowed before spawning follow-on work +- `mcp__orgx__orgx_bootstrap` — resolve workspace scope before review or publication +- `mcp__orgx__orgx_inspect` — hydrate task-bound context, attachments, and plan sessions +- `mcp__orgx__orgx_search` — Query existing design artifacts and related work +- `mcp__orgx__orgx_search` — Pull prior design decisions and learnings +- `mcp__orgx__orgx_search` — retrieve design-specific learnings before drafting +- `mcp__orgx__orgx_plan` — open tracked design planning sessions +- `mcp__orgx__orgx_plan` — refine interaction or system plans +- `mcp__orgx__orgx_plan` — capture major planning revisions +- `mcp__orgx__orgx_plan` — persist and attach finalized design plans +- `mcp__orgx__orgx_write` — Publish completed artifacts +- `mcp__orgx__orgx_act` — attach evidence and update entity state +- `mcp__orgx__orgx_submit_receipt` — Record design learnings for the flywheel +- `mcp__orgx__orgx_act` — Add design review comments to engineering work +- `mcp__orgx__orgx_submit_receipt` — score artifact quality for calibration +- `mcp__orgx__orgx_spawn` — verify delegation is allowed before spawning follow-on work ### Optional (when configured): @@ -819,7 +819,7 @@ python3 scripts/validate_design.py --type --type ``` 12. Fix all failed gates. -13. Publish with `mcp__orgx__create_entity`. +13. Publish with `mcp__orgx__orgx_write`. 14. Attach proof or conclusions back to the active entity: - - `mcp__orgx__complete_plan` with `attach_to` for plan sessions - - `mcp__orgx__entity_action` with `action=attach` for RFCs, reviews, and runbooks - - `mcp__orgx__comment_on_entity` for review findings or architectural guidance -15. Submit learnings: `mcp__orgx__submit_learning` with outcome-linked insight. -16. Score the artifact: `mcp__orgx__record_quality_score`. -17. Before spawning follow-on work, run `mcp__orgx__check_spawn_guard`, then delegate with `mcp__orgx__spawn_agent_task`. + - `mcp__orgx__orgx_plan` with `attach_to` for plan sessions + - `mcp__orgx__orgx_act` with `action=attach` for RFCs, reviews, and runbooks + - `mcp__orgx__orgx_act` for review findings or architectural guidance +15. Submit learnings: `mcp__orgx__orgx_submit_receipt` with outcome-linked insight. +16. Score the artifact: `mcp__orgx__orgx_submit_receipt`. +17. Before spawning follow-on work, run `mcp__orgx__orgx_spawn`, then delegate with `mcp__orgx__orgx_spawn`. ## Artifact Contracts @@ -443,14 +443,14 @@ If any of these five elements is missing from an incoming handoff, request clari ### Before Drafting -1. Call `mcp__orgx__get_relevant_learnings` scoped to the engineering domain and the specific artifact type. Look for patterns like "previous RFCs for this service underestimated migration effort by 2x" or "this team prefers ADRs over RFCs for decisions under 1 week of work." -2. Call `mcp__orgx__query_org_memory` with `scope: "decisions"` and a query covering the related architecture area. Check for superseded ADRs, rejected RFC alternatives that are relevant again, and postmortem action items that should constrain new designs. +1. Call `mcp__orgx__orgx_search` scoped to the engineering domain and the specific artifact type. Look for patterns like "previous RFCs for this service underestimated migration effort by 2x" or "this team prefers ADRs over RFCs for decisions under 1 week of work." +2. Call `mcp__orgx__orgx_search` with `scope: "decisions"` and a query covering the related architecture area. Check for superseded ADRs, rejected RFC alternatives that are relevant again, and postmortem action items that should constrain new designs. 3. Apply learnings as explicit constraints or confidence adjustments. If a learning says "database migrations for this service historically take 3x the estimate," note that in the risk section and adjust effort estimates accordingly. ### After Completion -1. Call `mcp__orgx__submit_learning` with an outcome-linked insight. The learning should be specific enough to help future artifact creation. Good: "RFC for service X required 3 revision cycles because the team had no observability — future RFCs for unobserved services should include an observability prerequisite phase." Bad: "RFCs are hard." -2. Call `mcp__orgx__record_quality_score` on the artifact with a score and rationale. The score should reflect how well the artifact met its contract, how much revision was needed, and how actionable the output is. +1. Call `mcp__orgx__orgx_submit_receipt` with an outcome-linked insight. The learning should be specific enough to help future artifact creation. Good: "RFC for service X required 3 revision cycles because the team had no observability — future RFCs for unobserved services should include an observability prerequisite phase." Bad: "RFCs are hard." +2. Call `mcp__orgx__orgx_submit_receipt` on the artifact with a score and rationale. The score should reflect how well the artifact met its contract, how much revision was needed, and how actionable the output is. ## Precision Loop (Run Every Time) @@ -481,22 +481,22 @@ Run the validator script and confirm zero errors. Verify that recommendation lan Primary: - `mcp__orgx__orgx_bootstrap` — initialize the OrgX session and recommended workflow -- `mcp__orgx__workspace` — resolve the active workspace before reading or writing -- `mcp__orgx__get_task_with_context` — hydrate task-bound context, attachments, and plan sessions -- `mcp__orgx__query_org_memory` — organizational precedent and context -- `mcp__orgx__list_entities` — related work items and initiatives -- `mcp__orgx__start_plan_session` — open tracked planning sessions for RFCs and migrations -- `mcp__orgx__improve_plan` — refine architecture and rollout plans -- `mcp__orgx__record_plan_edit` — capture meaningful planning revisions -- `mcp__orgx__complete_plan` — persist the final plan and attach it to entities -- `mcp__orgx__create_entity` — publish completed artifacts -- `mcp__orgx__entity_action` — attach evidence and update entity state -- `mcp__orgx__comment_on_entity` — write review or implementation notes onto the active entity -- `mcp__orgx__check_spawn_guard` — verify delegation is allowed before spawning execution -- `mcp__orgx__spawn_agent_task` — hand off implementation or investigation work -- `mcp__orgx__get_relevant_learnings` — domain-specific insights from previous work -- `mcp__orgx__submit_learning` — contribute learnings back to the flywheel -- `mcp__orgx__record_quality_score` — score artifact quality for continuous improvement +- `mcp__orgx__orgx_bootstrap` — resolve the active workspace before reading or writing +- `mcp__orgx__orgx_inspect` — hydrate task-bound context, attachments, and plan sessions +- `mcp__orgx__orgx_search` — organizational precedent and context +- `mcp__orgx__orgx_search` — related work items and initiatives +- `mcp__orgx__orgx_plan` — open tracked planning sessions for RFCs and migrations +- `mcp__orgx__orgx_plan` — refine architecture and rollout plans +- `mcp__orgx__orgx_plan` — capture meaningful planning revisions +- `mcp__orgx__orgx_plan` — persist the final plan and attach it to entities +- `mcp__orgx__orgx_write` — publish completed artifacts +- `mcp__orgx__orgx_act` — attach evidence and update entity state +- `mcp__orgx__orgx_act` — write review or implementation notes onto the active entity +- `mcp__orgx__orgx_spawn` — verify delegation is allowed before spawning execution +- `mcp__orgx__orgx_spawn` — hand off implementation or investigation work +- `mcp__orgx__orgx_search` — domain-specific insights from previous work +- `mcp__orgx__orgx_submit_receipt` — contribute learnings back to the flywheel +- `mcp__orgx__orgx_submit_receipt` — score artifact quality for continuous improvement Optional (if configured): diff --git a/engineering-agent/skill.toml b/engineering-agent/skill.toml index b84e924..2d6c083 100644 --- a/engineering-agent/skill.toml +++ b/engineering-agent/skill.toml @@ -2,6 +2,6 @@ name = "engineering-agent" version = "2.0.0" description = "Produce high-confidence engineering artifacts for OrgX: RFCs, ADRs, code reviews, postmortems, tech debt inventories, capacity plans, runbooks, migration playbooks, dependency audits, and performance budgets. Use when technical decisions, implementation risk, reliability analysis, or engineering quality gates are required." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_task_with_context", "mcp__orgx__query_org_memory", "mcp__orgx__list_entities", "mcp__orgx__start_plan_session", "mcp__orgx__improve_plan", "mcp__orgx__record_plan_edit", "mcp__orgx__complete_plan", "mcp__orgx__create_entity", "mcp__orgx__entity_action", "mcp__orgx__comment_on_entity", "mcp__orgx__check_spawn_guard", "mcp__orgx__spawn_agent_task", "mcp__orgx__get_relevant_learnings", "mcp__orgx__submit_learning", "mcp__orgx__record_quality_score"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_search", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_submit_receipt"] required_scopes = [] resources = [] diff --git a/initiative-kickoff/SKILL.md b/initiative-kickoff/SKILL.md index 72a82f7..697d308 100644 --- a/initiative-kickoff/SKILL.md +++ b/initiative-kickoff/SKILL.md @@ -15,9 +15,9 @@ Transform a goal into a structured OrgX initiative with milestones, workstreams, ## Quick Start 1. Bootstrap the session with `mcp__orgx__orgx_bootstrap`. -2. Confirm or set the target workspace with `mcp__orgx__workspace`. +2. Confirm or set the target workspace with `mcp__orgx__orgx_bootstrap`. 3. Check for duplicate or overlapping initiatives. -4. Prefer `mcp__orgx__scaffold_initiative` for the full hierarchy. +4. Prefer `mcp__orgx__orgx_write` for the full hierarchy. 5. Launch only if the user wants execution to start now. ## Workflow @@ -28,14 +28,14 @@ Transform a goal into a structured OrgX initiative with milestones, workstreams, - timeline hints - success indicators 2. Check context: - - `mcp__orgx__list_entities type=initiative` - - `mcp__orgx__query_org_memory` for similar efforts or prior decisions -3. Create the full hierarchy with `mcp__orgx__scaffold_initiative`. + - `mcp__orgx__orgx_search type=initiative` + - `mcp__orgx__orgx_search` for similar efforts or prior decisions +3. Create the full hierarchy with `mcp__orgx__orgx_write`. 4. If the user requests specific agent delegation: - - call `mcp__orgx__check_spawn_guard` - - then `mcp__orgx__spawn_agent_task` -5. Launch with `mcp__orgx__entity_action type=initiative action=launch` when the initiative should go live immediately. -6. Finish with `mcp__orgx__recommend_next_action` so the user knows the first move after kickoff. + - call `mcp__orgx__orgx_spawn` + - then `mcp__orgx__orgx_spawn` +5. Launch with `mcp__orgx__orgx_act type=initiative action=launch` when the initiative should go live immediately. +6. Finish with `mcp__orgx__orgx_recommend` so the user knows the first move after kickoff. ## Default Structure diff --git a/initiative-kickoff/instructions.md b/initiative-kickoff/instructions.md index debc94f..975c6eb 100644 --- a/initiative-kickoff/instructions.md +++ b/initiative-kickoff/instructions.md @@ -3,15 +3,15 @@ You are creating a new OrgX initiative from a single goal statement. ## Required Sequence 1. Call `mcp__orgx__orgx_bootstrap`. -2. Call `mcp__orgx__workspace action=get`. -3. If no workspace is active, call `mcp__orgx__workspace action=list`, pick the default (or ask the user if the choice is ambiguous), then call `mcp__orgx__workspace action=set`. +2. Call `mcp__orgx__orgx_bootstrap action=get`. +3. If no workspace is active, call `mcp__orgx__orgx_bootstrap action=list`, pick the default (or ask the user if the choice is ambiguous), then call `mcp__orgx__orgx_bootstrap action=set`. 4. Check for overlapping initiatives with: - - `mcp__orgx__list_entities type=initiative` - - `mcp__orgx__query_org_memory` -5. Prefer `mcp__orgx__scaffold_initiative` to create the full initiative, workstream, milestone, and starter-task hierarchy in one call. -6. If the user asks for agent delegation, call `mcp__orgx__check_spawn_guard` before `mcp__orgx__spawn_agent_task`. -7. If the user wants execution to begin now, launch with `mcp__orgx__entity_action type=initiative action=launch`. -8. End with `mcp__orgx__recommend_next_action` for the created initiative. + - `mcp__orgx__orgx_search type=initiative` + - `mcp__orgx__orgx_search` +5. Prefer `mcp__orgx__orgx_write` to create the full initiative, workstream, milestone, and starter-task hierarchy in one call. +6. If the user asks for agent delegation, call `mcp__orgx__orgx_spawn` before `mcp__orgx__orgx_spawn`. +7. If the user wants execution to begin now, launch with `mcp__orgx__orgx_act type=initiative action=launch`. +8. End with `mcp__orgx__orgx_recommend` for the created initiative. ## Hierarchy Expectations diff --git a/initiative-kickoff/skill.toml b/initiative-kickoff/skill.toml index 3f6771f..5b71f6c 100644 --- a/initiative-kickoff/skill.toml +++ b/initiative-kickoff/skill.toml @@ -2,6 +2,6 @@ name = "initiative-kickoff" version = "2.0.0" description = "From a one-line goal, creates a complete initiative with scaffolded hierarchy, current workspace context, and optional guarded agent assignments" entry_instructions = "instructions.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__list_entities", "mcp__orgx__query_org_memory", "mcp__orgx__scaffold_initiative", "mcp__orgx__entity_action", "mcp__orgx__check_spawn_guard", "mcp__orgx__spawn_agent_task", "mcp__orgx__recommend_next_action"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_recommend"] required_scopes = [] resources = ["checklist.md"] diff --git a/initiative-protocol/SKILL.md b/initiative-protocol/SKILL.md index 946372c..cdc4f2d 100644 --- a/initiative-protocol/SKILL.md +++ b/initiative-protocol/SKILL.md @@ -14,43 +14,43 @@ Use this protocol whenever the user is creating, updating, launching, pausing, o ## Core Loop 1. Bootstrap the session with `mcp__orgx__orgx_bootstrap`. -2. Ensure the correct workspace is active with `mcp__orgx__workspace`. -3. Load the target initiative with `mcp__orgx__list_entities` or `mcp__orgx__get_initiative_pulse`. +2. Ensure the correct workspace is active with `mcp__orgx__orgx_bootstrap`. +3. Load the target initiative with `mcp__orgx__orgx_search` or `mcp__orgx__orgx_recommend`. 4. Create or update the hierarchy using the highest-level wrapper available. 5. Attach evidence, plans, and notes back to the initiative before marking it complete. ## Creating an Initiative 1. Check for related work: - - `mcp__orgx__query_org_memory` for prior initiatives or decisions - - `mcp__orgx__list_entities type=initiative` for active duplicates -2. Prefer `mcp__orgx__scaffold_initiative` when the request includes milestones, workstreams, or starter tasks. -3. Use `mcp__orgx__create_entity type=initiative` only for a single initiative shell with no nested hierarchy yet. + - `mcp__orgx__orgx_search` for prior initiatives or decisions + - `mcp__orgx__orgx_search type=initiative` for active duplicates +2. Prefer `mcp__orgx__orgx_write` when the request includes milestones, workstreams, or starter tasks. +3. Use `mcp__orgx__orgx_write type=initiative` only for a single initiative shell with no nested hierarchy yet. 4. For follow-on edits, prefer: - - `mcp__orgx__create_milestone` - - `mcp__orgx__create_task` - - `mcp__orgx__batch_create_entities` when creating several related children at once -5. Launch or pause through `mcp__orgx__entity_action`: + - `mcp__orgx__orgx_write` + - `mcp__orgx__orgx_write` + - `mcp__orgx__orgx_write` when creating several related children at once +5. Launch or pause through `mcp__orgx__orgx_act`: - launch: `type=initiative action=launch` - pause: `type=initiative action=pause` ## Monitoring -- `mcp__orgx__get_initiative_pulse` for health, blockers, and milestones -- `mcp__orgx__get_initiative_stream_state` for stream progress and bottlenecks -- `mcp__orgx__recommend_next_action` when the user asks what to do next -- `mcp__orgx__comment_on_entity` for status notes that should live on the initiative itself +- `mcp__orgx__orgx_recommend` for health, blockers, and milestones +- `mcp__orgx__orgx_inspect` for stream progress and bottlenecks +- `mcp__orgx__orgx_recommend` when the user asks what to do next +- `mcp__orgx__orgx_act` for status notes that should live on the initiative itself ## Completion 1. Confirm all dependent work is done or intentionally deferred. -2. Run `mcp__orgx__verify_entity_completion type=initiative`. -3. Attach proof with `mcp__orgx__entity_action action=attach` for plans, docs, URLs, or deliverable artifacts. -4. If planning happened in OrgX, finish the plan loop with `mcp__orgx__complete_plan attach_to=[...]` so the rationale is attached to the initiative context. -5. Mark complete with `mcp__orgx__entity_action type=initiative action=complete`. +2. Run `mcp__orgx__orgx_act type=initiative`. +3. Attach proof with `mcp__orgx__orgx_act action=attach` for plans, docs, URLs, or deliverable artifacts. +4. If planning happened in OrgX, finish the plan loop with `mcp__orgx__orgx_plan attach_to=[...]` so the rationale is attached to the initiative context. +5. Mark complete with `mcp__orgx__orgx_act type=initiative action=complete`. ## Risk Handling -- Use `mcp__orgx__entity_action type=initiative action=pause note="..."` for blockers or intentional holds. -- Use `mcp__orgx__queue_action` or `mcp__orgx__pin_workstream` when the priority problem is sequencing, not state. -- Use `mcp__orgx__comment_on_entity` instead of burying exceptions in the chat transcript. +- Use `mcp__orgx__orgx_act type=initiative action=pause note="..."` for blockers or intentional holds. +- Use `mcp__orgx__orgx_act` or `mcp__orgx__orgx_act` when the priority problem is sequencing, not state. +- Use `mcp__orgx__orgx_act` instead of burying exceptions in the chat transcript. diff --git a/initiative-protocol/skill.toml b/initiative-protocol/skill.toml index 1a29de1..db610a9 100644 --- a/initiative-protocol/skill.toml +++ b/initiative-protocol/skill.toml @@ -2,6 +2,6 @@ name = "initiative-protocol" version = "2.0.0" description = "Initiative lifecycle management for OrgX with workspace resolution, hierarchy scaffolding, monitoring, evidence attachment, and completion verification." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__query_org_memory", "mcp__orgx__list_entities", "mcp__orgx__scaffold_initiative", "mcp__orgx__create_entity", "mcp__orgx__create_milestone", "mcp__orgx__create_task", "mcp__orgx__batch_create_entities", "mcp__orgx__entity_action", "mcp__orgx__get_initiative_pulse", "mcp__orgx__get_initiative_stream_state", "mcp__orgx__verify_entity_completion", "mcp__orgx__comment_on_entity", "mcp__orgx__recommend_next_action", "mcp__orgx__complete_plan"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_write", "mcp__orgx__orgx_write", "mcp__orgx__orgx_write", "mcp__orgx__orgx_write", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_plan"] required_scopes = [] resources = [] diff --git a/marketing-agent/SKILL.md b/marketing-agent/SKILL.md index cadaa5b..d55e285 100644 --- a/marketing-agent/SKILL.md +++ b/marketing-agent/SKILL.md @@ -10,16 +10,16 @@ description: | ## Quick Start -1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__workspace`. -2. Confirm the artifact or decision type and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__get_task_with_context`; otherwise map relevant initiatives and prior artifacts with `mcp__orgx__list_entities`. -3. Pull precedent with `mcp__orgx__query_org_memory` and `mcp__orgx__get_relevant_learnings`. -4. For launch plans or initiative decomposition, use the planning loop: `mcp__orgx__start_plan_session`, `mcp__orgx__improve_plan`, `mcp__orgx__record_plan_edit`, then `mcp__orgx__complete_plan`. +1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__orgx_bootstrap`. +2. Confirm the artifact or decision type and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__orgx_inspect`; otherwise map relevant initiatives and prior artifacts with `mcp__orgx__orgx_search`. +3. Pull precedent with `mcp__orgx__orgx_search` and `mcp__orgx__orgx_search`. +4. For launch plans or initiative decomposition, use the planning loop: `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, then `mcp__orgx__orgx_plan`. 5. Produce the artifact using the contract below and return: - A concise summary (3-6 bullets) - The artifact body (JSON or structured Markdown) - 3 actionable next steps -6. Attach the result back to the active task or initiative with `mcp__orgx__entity_action` (`action=attach`) or `mcp__orgx__comment_on_entity`. -7. Before handing off campaign execution, run `mcp__orgx__check_spawn_guard`, then use `mcp__orgx__spawn_agent_task`. +6. Attach the result back to the active task or initiative with `mcp__orgx__orgx_act` (`action=attach`) or `mcp__orgx__orgx_act`. +7. Before handing off campaign execution, run `mcp__orgx__orgx_spawn`, then use `mcp__orgx__orgx_spawn`. Deliver conversion-oriented, evidence-backed marketing assets with deterministic quality gates. @@ -391,7 +391,7 @@ When receiving context from another agent: When handing off to another agent: 1. Provide the artifact in the format specified by the target agent's contract. 2. Include a brief (3-5 sentence) context summary explaining the strategic intent. -3. Tag handoff in OrgX with `mcp__orgx__spawn_agent_task` and link to source artifact. +3. Tag handoff in OrgX with `mcp__orgx__orgx_spawn` and link to source artifact. --- @@ -401,18 +401,18 @@ This agent gets better over time by feeding learnings back into OrgX's memory sy ### After every artifact: -1. **Record what worked**: If the artifact is based on a previous campaign or positioning that performed well, cite the source and what made it effective via `mcp__orgx__submit_learning`. +1. **Record what worked**: If the artifact is based on a previous campaign or positioning that performed well, cite the source and what made it effective via `mcp__orgx__orgx_submit_receipt`. 2. **Record what failed**: If the artifact replaces or improves on a previous version, document what was wrong with the previous version and why. -3. **Update org memory**: Store the artifact's strategic assumptions (ICP, positioning angle, competitive frame) so future agents can reference them via `mcp__orgx__query_org_memory`. +3. **Update org memory**: Store the artifact's strategic assumptions (ICP, positioning angle, competitive frame) so future agents can reference them via `mcp__orgx__orgx_search`. 4. **Tag for measurement**: Every artifact must include at least one measurable hypothesis. When results come in (from sales-agent, from analytics, from user feedback), the learning should be recorded. ### Learning queries to run before drafting: ``` -mcp__orgx__query_org_memory({ query: "previous campaigns for [ICP/segment]" }) -mcp__orgx__query_org_memory({ query: "competitive positioning against [competitor]" }) -mcp__orgx__query_org_memory({ query: "messaging that performed well for [audience]" }) -mcp__orgx__query_org_memory({ query: "content performance data for [channel]" }) +mcp__orgx__orgx_search({ query: "previous campaigns for [ICP/segment]" }) +mcp__orgx__orgx_search({ query: "competitive positioning against [competitor]" }) +mcp__orgx__orgx_search({ query: "messaging that performed well for [audience]" }) +mcp__orgx__orgx_search({ query: "content performance data for [channel]" }) ``` Use findings to inform the new artifact. Cite previous learnings explicitly: "Based on Q4 campaign results showing 3.2x higher CTR with outcome-led messaging (ref: campaign-2024-q4-analytics-launch), this brief leads with customer outcomes rather than feature descriptions." @@ -421,21 +421,21 @@ Use findings to inform the new artifact. Cite previous learnings explicitly: "Ba ## Operating Workflow -1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__workspace`. +1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__orgx_bootstrap`. 2. Choose `artifact_type` and define one primary goal metric. 3. Hydrate context: - - `mcp__orgx__get_task_with_context` for active task work - - `mcp__orgx__list_entities` for related initiatives, prior briefs, and existing content + - `mcp__orgx__orgx_inspect` for active task work + - `mcp__orgx__orgx_search` for related initiatives, prior briefs, and existing content 4. Run context adaptation protocol -- classify company stage, audience type, and GTM motion. 5. Gather evidence: -- Prior campaign context from `mcp__orgx__query_org_memory` -- Prior learnings from `mcp__orgx__get_relevant_learnings` -- Existing artifacts from `mcp__orgx__list_entities` +- Prior campaign context from `mcp__orgx__orgx_search` +- Prior learnings from `mcp__orgx__orgx_search` +- Existing artifacts from `mcp__orgx__orgx_search` - Channel constraints from CMS or content platform when available - Competitive context from org memory or provided intel -6. For launch plans, messaging frameworks, or initiative decomposition, open a plan session with `mcp__orgx__start_plan_session`, refine with `mcp__orgx__improve_plan`, and log major revisions with `mcp__orgx__record_plan_edit`. +6. For launch plans, messaging frameworks, or initiative decomposition, open a plan session with `mcp__orgx__orgx_plan`, refine with `mcp__orgx__orgx_plan`, and log major revisions with `mcp__orgx__orgx_plan`. 7. Select frameworks -- choose 1-3 frameworks from the Domain Expertise Canon that are most relevant to this artifact type and context. 8. Draft JSON-first artifact following the contract for the chosen type. 9. Run the Precision Loop (see below). @@ -445,14 +445,14 @@ Use findings to inform the new artifact. Cite previous learnings explicitly: "Ba python3 scripts/validate_marketing.py --type ``` -11. Fix all failed gates, then publish with `mcp__orgx__create_entity`. +11. Fix all failed gates, then publish with `mcp__orgx__orgx_write`. 12. Attach proof or conclusions back to the active work: - - `mcp__orgx__complete_plan` with `attach_to` for completed plan sessions - - `mcp__orgx__entity_action` with `action=attach` for campaign briefs, launch plans, and messaging docs - - `mcp__orgx__comment_on_entity` for feedback or decision notes -13. Record learnings via `mcp__orgx__submit_learning`. -14. Record artifact quality via `mcp__orgx__record_quality_score`. -15. Before handing off execution, run `mcp__orgx__check_spawn_guard`, then use `mcp__orgx__spawn_agent_task`. + - `mcp__orgx__orgx_plan` with `attach_to` for completed plan sessions + - `mcp__orgx__orgx_act` with `action=attach` for campaign briefs, launch plans, and messaging docs + - `mcp__orgx__orgx_act` for feedback or decision notes +13. Record learnings via `mcp__orgx__orgx_submit_receipt`. +14. Record artifact quality via `mcp__orgx__orgx_submit_receipt`. +15. Before handing off execution, run `mcp__orgx__orgx_spawn`, then use `mcp__orgx__orgx_spawn`. --- @@ -487,24 +487,24 @@ Before marking any artifact as complete, verify these strategic questions are an Primary: - `mcp__orgx__orgx_bootstrap` -- initialize OrgX session scope and recommended workflow -- `mcp__orgx__workspace` -- resolve or switch workspace scope -- `mcp__orgx__get_task_with_context` -- hydrate task-bound context, attachments, and plan sessions -- `mcp__orgx__query_org_memory` -- retrieve prior campaigns, learnings, competitive intel -- `mcp__orgx__get_relevant_learnings` -- pull prior GTM learnings before drafting -- `mcp__orgx__list_entities` -- find existing artifacts, initiatives, and context -- `mcp__orgx__start_plan_session` -- open tracked planning sessions for launch and messaging work -- `mcp__orgx__improve_plan` -- refine campaign or launch plans -- `mcp__orgx__record_plan_edit` -- capture material revisions to the plan -- `mcp__orgx__complete_plan` -- finalize and attach the plan to OrgX entities -- `mcp__orgx__create_entity` -- publish completed artifacts -- `mcp__orgx__entity_action` -- attach evidence and update entity state -- `mcp__orgx__comment_on_entity` -- leave review notes on active initiatives or tasks -- `mcp__orgx__check_spawn_guard` -- verify delegation is allowed before handoff -- `mcp__orgx__spawn_agent_task` -- hand off to other agents -- `mcp__orgx__submit_learning` -- record learnings for the flywheel -- `mcp__orgx__record_quality_score` -- record artifact quality for calibration -- `mcp__orgx__get_org_snapshot` -- understand current org state and priorities -- `mcp__orgx__recommend_next_action` -- identify highest-leverage marketing action +- `mcp__orgx__orgx_bootstrap` -- resolve or switch workspace scope +- `mcp__orgx__orgx_inspect` -- hydrate task-bound context, attachments, and plan sessions +- `mcp__orgx__orgx_search` -- retrieve prior campaigns, learnings, competitive intel +- `mcp__orgx__orgx_search` -- pull prior GTM learnings before drafting +- `mcp__orgx__orgx_search` -- find existing artifacts, initiatives, and context +- `mcp__orgx__orgx_plan` -- open tracked planning sessions for launch and messaging work +- `mcp__orgx__orgx_plan` -- refine campaign or launch plans +- `mcp__orgx__orgx_plan` -- capture material revisions to the plan +- `mcp__orgx__orgx_plan` -- finalize and attach the plan to OrgX entities +- `mcp__orgx__orgx_write` -- publish completed artifacts +- `mcp__orgx__orgx_act` -- attach evidence and update entity state +- `mcp__orgx__orgx_act` -- leave review notes on active initiatives or tasks +- `mcp__orgx__orgx_spawn` -- verify delegation is allowed before handoff +- `mcp__orgx__orgx_spawn` -- hand off to other agents +- `mcp__orgx__orgx_submit_receipt` -- record learnings for the flywheel +- `mcp__orgx__orgx_submit_receipt` -- record artifact quality for calibration +- `mcp__orgx__orgx_recommend` -- understand current org state and priorities +- `mcp__orgx__orgx_recommend` -- identify highest-leverage marketing action Optional (if configured): @@ -517,8 +517,8 @@ Optional (if configured): ## Failure Handling - **Missing ICP precision**: Provide two candidate ICPs with reasoning for each. Mark the primary as an assumption. Do not proceed with generic targeting. -- **Missing brand rules**: Default to existing OrgX tone from org memory and tag all creative direction as provisional. Query: `mcp__orgx__query_org_memory({ query: "brand voice guidelines" })`. -- **Missing competitive intel**: State what is known, flag gaps explicitly, and recommend competitive research as a prerequisite task via `mcp__orgx__spawn_agent_task`. +- **Missing brand rules**: Default to existing OrgX tone from org memory and tag all creative direction as provisional. Query: `mcp__orgx__orgx_search({ query: "brand voice guidelines" })`. +- **Missing competitive intel**: State what is known, flag gaps explicitly, and recommend competitive research as a prerequisite task via `mcp__orgx__orgx_spawn`. - **Missing performance data**: Use industry benchmarks as starting baselines, cite the source, and flag that baselines should be updated with actual data within 30 days. - **Validator errors**: Do not publish until fixed. Never override validation gates. - **Conflicting inputs**: When product-agent and sales-agent provide conflicting positioning, flag the conflict explicitly, present both framings, and recommend a positioning alignment session. diff --git a/marketing-agent/skill.toml b/marketing-agent/skill.toml index 3a4620e..3e1a937 100644 --- a/marketing-agent/skill.toml +++ b/marketing-agent/skill.toml @@ -2,6 +2,6 @@ name = "marketing-agent" version = "2.0.0" description = "Produce high-confidence marketing artifacts for OrgX: campaign briefs, multichannel content packs, nurture sequences, positioning documents, messaging matrices, competitive narratives, launch plans, analyst briefs, and community strategies. Use when go-to-market messaging, campaign strategy, content execution, or channel performance planning is needed." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_task_with_context", "mcp__orgx__query_org_memory", "mcp__orgx__list_entities", "mcp__orgx__start_plan_session", "mcp__orgx__improve_plan", "mcp__orgx__record_plan_edit", "mcp__orgx__complete_plan", "mcp__orgx__create_entity", "mcp__orgx__entity_action", "mcp__orgx__comment_on_entity", "mcp__orgx__check_spawn_guard", "mcp__orgx__spawn_agent_task", "mcp__orgx__get_relevant_learnings", "mcp__orgx__submit_learning", "mcp__orgx__record_quality_score", "mcp__orgx__get_org_snapshot", "mcp__orgx__recommend_next_action"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_search", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_recommend"] required_scopes = [] resources = [] diff --git a/milestone-protocol/SKILL.md b/milestone-protocol/SKILL.md index 15690dc..fd2d29a 100644 --- a/milestone-protocol/SKILL.md +++ b/milestone-protocol/SKILL.md @@ -14,34 +14,34 @@ Milestones are checkpoints with explicit deliverables. Treat them as proof gates ## Core Loop -1. Bootstrap and confirm workspace with `mcp__orgx__orgx_bootstrap` and `mcp__orgx__workspace`. -2. Load the parent initiative or workstream with `mcp__orgx__list_entities`. +1. Bootstrap and confirm workspace with `mcp__orgx__orgx_bootstrap` and `mcp__orgx__orgx_bootstrap`. +2. Load the parent initiative or workstream with `mcp__orgx__orgx_search`. 3. Create or update the milestone. 4. Attach evidence as deliverables land. 5. Verify readiness before completing. ## Creating Milestones -- Prefer `mcp__orgx__create_milestone` when creating a single checkpoint. -- Use `mcp__orgx__batch_create_entities` when creating multiple milestones with shared refs. +- Prefer `mcp__orgx__orgx_write` when creating a single checkpoint. +- Use `mcp__orgx__orgx_write` when creating multiple milestones with shared refs. - Always link the milestone to its initiative, and workstream when applicable. - Include deliverables and `due_date`. ## Tracking Progress -- Start with `mcp__orgx__entity_action type=milestone action=launch`. -- Inspect status with `mcp__orgx__list_entities type=milestone` or the parent initiative pulse. -- Use `mcp__orgx__comment_on_entity` for checkpoint notes that should remain visible to operators. +- Start with `mcp__orgx__orgx_act type=milestone action=launch`. +- Inspect status with `mcp__orgx__orgx_search type=milestone` or the parent initiative pulse. +- Use `mcp__orgx__orgx_act` for checkpoint notes that should remain visible to operators. ## Flagging Risk -- Pause with `mcp__orgx__entity_action type=milestone action=pause note="..."`. +- Pause with `mcp__orgx__orgx_act type=milestone action=pause note="..."`. - Include the blocker, mitigation path, and owner. - Escalate cross-domain risks through the parent initiative or orchestrator comments, not only in chat. ## Completing 1. Verify all milestone deliverables are attached or linked. -2. Run `mcp__orgx__verify_entity_completion type=milestone`. -3. Attach proof with `mcp__orgx__entity_action action=attach`. -4. Complete with `mcp__orgx__entity_action type=milestone action=complete`. +2. Run `mcp__orgx__orgx_act type=milestone`. +3. Attach proof with `mcp__orgx__orgx_act action=attach`. +4. Complete with `mcp__orgx__orgx_act type=milestone action=complete`. diff --git a/milestone-protocol/skill.toml b/milestone-protocol/skill.toml index 6caef3b..ea264aa 100644 --- a/milestone-protocol/skill.toml +++ b/milestone-protocol/skill.toml @@ -2,6 +2,6 @@ name = "milestone-protocol" version = "2.0.0" description = "Milestone checkpoint management for OrgX initiatives with launch, pause, evidence attachment, and completion verification." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__create_milestone", "mcp__orgx__batch_create_entities", "mcp__orgx__list_entities", "mcp__orgx__entity_action", "mcp__orgx__verify_entity_completion", "mcp__orgx__comment_on_entity"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_write", "mcp__orgx__orgx_write", "mcp__orgx__orgx_search", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act"] required_scopes = [] resources = [] diff --git a/morning-briefing/SKILL.md b/morning-briefing/SKILL.md index 8efea89..a56695d 100644 --- a/morning-briefing/SKILL.md +++ b/morning-briefing/SKILL.md @@ -14,14 +14,14 @@ Generate a concise daily status report for the active OrgX workspace. ## Workflow 1. Bootstrap with `mcp__orgx__orgx_bootstrap`. -2. Resolve the workspace with `mcp__orgx__workspace`. +2. Resolve the workspace with `mcp__orgx__orgx_bootstrap`. 3. Fetch: - - `mcp__orgx__get_morning_brief` - - `mcp__orgx__list_entities type=decision status=pending` - - `mcp__orgx__list_entities type=task status=blocked` - - `mcp__orgx__get_agent_status include_idle=false` - - `mcp__orgx__get_org_snapshot` - - `mcp__orgx__recommend_next_action entity_type=workspace` + - `mcp__orgx__orgx_recommend` + - `mcp__orgx__orgx_search type=decision status=pending` + - `mcp__orgx__orgx_search type=task status=blocked` + - `mcp__orgx__orgx_recommend include_idle=false` + - `mcp__orgx__orgx_recommend` + - `mcp__orgx__orgx_recommend entity_type=workspace` 4. Prioritize the briefing: - critical decisions - blocked work the user can unblock diff --git a/morning-briefing/instructions.md b/morning-briefing/instructions.md index 367567b..b21b170 100644 --- a/morning-briefing/instructions.md +++ b/morning-briefing/instructions.md @@ -3,14 +3,14 @@ You are generating the morning briefing for the user's OrgX workspace. ## Required Sequence 1. Call `mcp__orgx__orgx_bootstrap`. -2. Resolve the active workspace with `mcp__orgx__workspace`. +2. Resolve the active workspace with `mcp__orgx__orgx_bootstrap`. 3. Collect: - - `mcp__orgx__get_morning_brief` - - `mcp__orgx__list_entities` for pending decisions - - `mcp__orgx__list_entities` for blocked tasks - - `mcp__orgx__get_agent_status include_idle=false` - - `mcp__orgx__get_org_snapshot` - - `mcp__orgx__recommend_next_action entity_type=workspace` + - `mcp__orgx__orgx_recommend` + - `mcp__orgx__orgx_search` for pending decisions + - `mcp__orgx__orgx_search` for blocked tasks + - `mcp__orgx__orgx_recommend include_idle=false` + - `mcp__orgx__orgx_recommend` + - `mcp__orgx__orgx_recommend entity_type=workspace` ## Output Rules diff --git a/morning-briefing/skill.toml b/morning-briefing/skill.toml index ef77a39..ef86bf8 100644 --- a/morning-briefing/skill.toml +++ b/morning-briefing/skill.toml @@ -2,6 +2,6 @@ name = "morning-briefing" version = "2.0.0" description = "Get your daily OrgX briefing with workspace-aware value signals, pending decisions, blocked work, agent status, initiative health, and the single best next action" entry_instructions = "instructions.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_morning_brief", "mcp__orgx__get_agent_status", "mcp__orgx__list_entities", "mcp__orgx__get_org_snapshot", "mcp__orgx__recommend_next_action"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_search", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_recommend"] required_scopes = [] resources = [] diff --git a/nightly-recap/SKILL.md b/nightly-recap/SKILL.md index b3d7ba0..d840870 100644 --- a/nightly-recap/SKILL.md +++ b/nightly-recap/SKILL.md @@ -14,13 +14,13 @@ Generate an end-of-day OrgX summary for the active workspace. ## Required Sequence 1. Call `mcp__orgx__orgx_bootstrap`. -2. Resolve the workspace with `mcp__orgx__workspace`. +2. Resolve the workspace with `mcp__orgx__orgx_bootstrap`. 3. Gather: - - `mcp__orgx__get_org_snapshot` - - `mcp__orgx__list_entities type=task status=done` - - `mcp__orgx__list_entities type=decision status=pending` - - `mcp__orgx__get_agent_status include_idle=true` - - `mcp__orgx__recommend_next_action entity_type=workspace` + - `mcp__orgx__orgx_recommend` + - `mcp__orgx__orgx_search type=task status=done` + - `mcp__orgx__orgx_search type=decision status=pending` + - `mcp__orgx__orgx_recommend include_idle=true` + - `mcp__orgx__orgx_recommend entity_type=workspace` ## Output diff --git a/nightly-recap/skill.toml b/nightly-recap/skill.toml index f9abc00..17d0142 100644 --- a/nightly-recap/skill.toml +++ b/nightly-recap/skill.toml @@ -2,6 +2,6 @@ name = "nightly-recap" version = "1.0.0" description = "Draft nightly OrgX recaps with completed work, pending approvals, agent activity, and tomorrow's first move." entry_instructions = "instructions.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_org_snapshot", "mcp__orgx__list_entities", "mcp__orgx__get_agent_status", "mcp__orgx__recommend_next_action"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_search", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_recommend"] required_scopes = [] resources = ["checklist.md"] diff --git a/operations-agent/SKILL.md b/operations-agent/SKILL.md index 54e1020..c4fc601 100644 --- a/operations-agent/SKILL.md +++ b/operations-agent/SKILL.md @@ -10,17 +10,17 @@ description: | ## Quick Start -1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__workspace`. -2. Confirm the artifact or decision type and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__get_task_with_context`; otherwise map related work with `mcp__orgx__list_entities`. -3. Pull precedent with `mcp__orgx__query_org_memory` and `mcp__orgx__get_relevant_learnings`. -4. For playbooks, migrations, or SLO programs, use the planning loop: `mcp__orgx__start_plan_session`, `mcp__orgx__improve_plan`, `mcp__orgx__record_plan_edit`, then `mcp__orgx__complete_plan`. +1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__orgx_bootstrap`. +2. Confirm the artifact or decision type and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__orgx_inspect`; otherwise map related work with `mcp__orgx__orgx_search`. +3. Pull precedent with `mcp__orgx__orgx_search` and `mcp__orgx__orgx_search`. +4. For playbooks, migrations, or SLO programs, use the planning loop: `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, then `mcp__orgx__orgx_plan`. 5. Identify the operational maturity stage (see Context Adaptation Protocol) and calibrate depth. 6. Produce the artifact using the contract below and return: - A concise summary (3-6 bullets) - The artifact body (JSON or structured Markdown) - 3 actionable next steps 7. Run the Precision Loop before publishing. -8. Attach the result back to the active task or initiative with `mcp__orgx__entity_action` (`action=attach`) or `mcp__orgx__comment_on_entity`, then record quality with `mcp__orgx__record_quality_score`. +8. Attach the result back to the active task or initiative with `mcp__orgx__orgx_act` (`action=attach`) or `mcp__orgx__orgx_act`, then record quality with `mcp__orgx__orgx_submit_receipt`. Deliver operational artifacts that reduce incident risk, improve response quality, and drive systematic reliability improvement. @@ -179,19 +179,19 @@ When producing any artifact, identify the applicable signals first and adjust ar ## Operating Workflow -1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__workspace`. +1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__orgx_bootstrap`. 2. Pick `artifact_type` and define success condition. 3. Hydrate the active task or parent entity: - - `mcp__orgx__get_task_with_context` for task-bound work - - `mcp__orgx__list_entities` for surrounding initiatives, milestones, and prior incidents or playbooks + - `mcp__orgx__orgx_inspect` for task-bound work + - `mcp__orgx__orgx_search` for surrounding initiatives, milestones, and prior incidents or playbooks 4. Identify organizational maturity signals from Context Adaptation Protocol. 5. Gather evidence: - - OrgX context: `mcp__orgx__query_org_memory`, `mcp__orgx__list_entities` - - Prior learnings: `mcp__orgx__get_relevant_learnings` + - OrgX context: `mcp__orgx__orgx_search`, `mcp__orgx__orgx_search` + - Prior learnings: `mcp__orgx__orgx_search` - Incident context: PagerDuty/observability tools when available - Cost data: cloud provider billing, FinOps tooling - Capacity data: APM, load balancer metrics, database metrics -6. For programmatic operational plans, open a plan session with `mcp__orgx__start_plan_session`, refine with `mcp__orgx__improve_plan`, and record major revisions with `mcp__orgx__record_plan_edit`. +6. For programmatic operational plans, open a plan session with `mcp__orgx__orgx_plan`, refine with `mcp__orgx__orgx_plan`, and record major revisions with `mcp__orgx__orgx_plan`. 7. Apply relevant frameworks from Domain Expertise Canon. 8. Draft JSON-first artifact following the contract for the selected type. 9. Run the Precision Loop (all 4 passes). @@ -201,14 +201,14 @@ When producing any artifact, identify the applicable signals first and adjust ar python3 scripts/validate_ops.py --type ``` -11. Resolve all failed gates, then publish via `mcp__orgx__create_entity`. +11. Resolve all failed gates, then publish via `mcp__orgx__orgx_write`. 12. Attach proof or conclusions back to the active work: - - `mcp__orgx__complete_plan` with `attach_to` for plan sessions - - `mcp__orgx__entity_action` with `action=attach` for incidents, SLOs, budgets, and playbooks - - `mcp__orgx__comment_on_entity` for reviews or escalation notes -13. Submit learnings via `mcp__orgx__submit_learning`. -14. Record measurable outcomes with `mcp__orgx__record_outcome` when the artifact closes a reliability or cost event. -15. Record artifact quality with `mcp__orgx__record_quality_score`. + - `mcp__orgx__orgx_plan` with `attach_to` for plan sessions + - `mcp__orgx__orgx_act` with `action=attach` for incidents, SLOs, budgets, and playbooks + - `mcp__orgx__orgx_act` for reviews or escalation notes +13. Submit learnings via `mcp__orgx__orgx_submit_receipt`. +14. Record measurable outcomes with `mcp__orgx__orgx_submit_receipt` when the artifact closes a reliability or cost event. +15. Record artifact quality with `mcp__orgx__orgx_submit_receipt`. --- @@ -512,10 +512,10 @@ When handing off to another agent, structure the handoff as: Every operations artifact should feed the organizational learning loop: ### After Incident Analysis -- Submit key finding as learning: `mcp__orgx__submit_learning` with category `incident_pattern` +- Submit key finding as learning: `mcp__orgx__orgx_submit_receipt` with category `incident_pattern` - If this incident matches a previous pattern, reference the prior incident and note what was (or was not) fixed - Update the relevant runbook if the response uncovered gaps -- Record outcome via `mcp__orgx__record_outcome` with measurable impact +- Record outcome via `mcp__orgx__orgx_submit_receipt` with measurable impact ### After Playbook Creation - Link playbook to the alert or trigger condition it addresses @@ -541,7 +541,7 @@ Every operations artifact should feed the organizational learning loop: Before producing any artifact, check for prior learnings: ``` -mcp__orgx__get_relevant_learnings({ category: "operations", service: "" }) +mcp__orgx__orgx_search({ category: "operations", service: "" }) ``` Incorporate relevant prior learnings into the artifact. Reference them explicitly: "Prior incident INC-1234 identified this same connection pool issue; action item AI-5678 was to add connection pooling monitoring but remains open." @@ -553,22 +553,22 @@ Incorporate relevant prior learnings into the artifact. Reference them explicitl ### Primary - `mcp__orgx__orgx_bootstrap` — initialize OrgX session scope and recommended workflow -- `mcp__orgx__workspace` — resolve workspace scope before reading or writing -- `mcp__orgx__get_task_with_context` — hydrate task-bound context, attachments, and prior plan sessions -- `mcp__orgx__query_org_memory` — Retrieve organizational context and prior decisions -- `mcp__orgx__list_entities` — List initiatives, workstreams, tasks, milestones -- `mcp__orgx__start_plan_session` — open tracked planning sessions for playbooks, migrations, and SLO programs -- `mcp__orgx__improve_plan` — refine operational plans with historical patterns -- `mcp__orgx__record_plan_edit` — capture major planning revisions -- `mcp__orgx__complete_plan` — persist and attach finalized operational plans -- `mcp__orgx__create_entity` — Publish artifacts and create operational tasks -- `mcp__orgx__entity_action` — attach evidence and update operational state -- `mcp__orgx__comment_on_entity` — add operational notes and review feedback to active work -- `mcp__orgx__update_entity` — Update existing operational entities -- `mcp__orgx__submit_learning` — Feed findings into the learning loop -- `mcp__orgx__record_outcome` — Record measurable operational outcomes -- `mcp__orgx__record_quality_score` — score artifact quality for calibration -- `mcp__orgx__get_relevant_learnings` — Check for prior learnings before drafting +- `mcp__orgx__orgx_bootstrap` — resolve workspace scope before reading or writing +- `mcp__orgx__orgx_inspect` — hydrate task-bound context, attachments, and prior plan sessions +- `mcp__orgx__orgx_search` — Retrieve organizational context and prior decisions +- `mcp__orgx__orgx_search` — List initiatives, workstreams, tasks, milestones +- `mcp__orgx__orgx_plan` — open tracked planning sessions for playbooks, migrations, and SLO programs +- `mcp__orgx__orgx_plan` — refine operational plans with historical patterns +- `mcp__orgx__orgx_plan` — capture major planning revisions +- `mcp__orgx__orgx_plan` — persist and attach finalized operational plans +- `mcp__orgx__orgx_write` — Publish artifacts and create operational tasks +- `mcp__orgx__orgx_act` — attach evidence and update operational state +- `mcp__orgx__orgx_act` — add operational notes and review feedback to active work +- `mcp__orgx__orgx_write` — Update existing operational entities +- `mcp__orgx__orgx_submit_receipt` — Feed findings into the learning loop +- `mcp__orgx__orgx_submit_receipt` — Record measurable operational outcomes +- `mcp__orgx__orgx_submit_receipt` — score artifact quality for calibration +- `mcp__orgx__orgx_search` — Check for prior learnings before drafting ### Optional (if configured) @@ -609,5 +609,5 @@ Incorporate relevant prior learnings into the artifact. Reference them explicitl - Migration checklists include rollback procedure for every phase. - On-call audits include burnout indicators and compensation fairness assessment. - Artifact is persisted in OrgX with traceable evidence links. -- Relevant learnings submitted to the flywheel via `mcp__orgx__submit_learning`. +- Relevant learnings submitted to the flywheel via `mcp__orgx__orgx_submit_receipt`. - Cross-agent handoffs dispatched if the artifact reveals work for another agent. diff --git a/operations-agent/skill.toml b/operations-agent/skill.toml index 7c0a748..9dc0161 100644 --- a/operations-agent/skill.toml +++ b/operations-agent/skill.toml @@ -2,6 +2,6 @@ name = "operations-agent" version = "2.0.0" description = "Produce high-confidence operations artifacts for OrgX: incident analyses, operational playbooks, budget controls, capacity plans, vendor evaluations, SLO proposals, chaos test plans, migration checklists, and on-call rotation audits. Use when reliability, incident management, escalation readiness, or operational cost governance is required." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_task_with_context", "mcp__orgx__query_org_memory", "mcp__orgx__list_entities", "mcp__orgx__start_plan_session", "mcp__orgx__improve_plan", "mcp__orgx__record_plan_edit", "mcp__orgx__complete_plan", "mcp__orgx__create_entity", "mcp__orgx__entity_action", "mcp__orgx__comment_on_entity", "mcp__orgx__update_entity", "mcp__orgx__submit_learning", "mcp__orgx__record_outcome", "mcp__orgx__record_quality_score", "mcp__orgx__get_relevant_learnings"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act", "mcp__orgx__orgx_write", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_search"] required_scopes = [] resources = ["evaluations/ops-evaluation.json", "examples/incident-analysis.md", "examples/slo-proposal.md", "reference/ops-frameworks-cheatsheet.md", "reference/incident-template.md"] diff --git a/orchestrator-agent/SKILL.md b/orchestrator-agent/SKILL.md index 95595ee..349da78 100644 --- a/orchestrator-agent/SKILL.md +++ b/orchestrator-agent/SKILL.md @@ -11,18 +11,18 @@ description: | ## Quick Start -1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__workspace`. -2. Confirm the artifact or decision type and the target audience. If the work is task-bound, hydrate it with `mcp__orgx__get_task_with_context`; otherwise map the surrounding initiative with `mcp__orgx__list_entities` and `mcp__orgx__get_initiative_pulse`. -3. Retrieve relevant learnings with `mcp__orgx__get_relevant_learnings` and prior coordination decisions with `mcp__orgx__query_org_memory` scoped to decisions. -4. For new initiative formation, prefer `mcp__orgx__scaffold_initiative`. For strategy-heavy coordination work, run a planning loop with `mcp__orgx__start_plan_session`, `mcp__orgx__improve_plan`, `mcp__orgx__record_plan_edit`, and `mcp__orgx__complete_plan`. +1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__orgx_bootstrap`. +2. Confirm the artifact or decision type and the target audience. If the work is task-bound, hydrate it with `mcp__orgx__orgx_inspect`; otherwise map the surrounding initiative with `mcp__orgx__orgx_search` and `mcp__orgx__orgx_recommend`. +3. Retrieve relevant learnings with `mcp__orgx__orgx_search` and prior coordination decisions with `mcp__orgx__orgx_search` scoped to decisions. +4. For new initiative formation, prefer `mcp__orgx__orgx_write`. For strategy-heavy coordination work, run a planning loop with `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, and `mcp__orgx__orgx_plan`. 5. Assess the coordination context (number of agents, dependency complexity, time horizon) and adapt formality accordingly. 6. Produce the artifact using the contract below and return: - A concise summary (3-6 bullets) - The artifact body (JSON or structured Markdown) - 3 actionable next steps with owners and deadlines -7. Attach proof back to the initiative, task, or decision with `mcp__orgx__entity_action` (`action=attach`) or `mcp__orgx__comment_on_entity`. -8. Before every delegation, run `mcp__orgx__check_spawn_guard`, then use `mcp__orgx__spawn_agent_task`. -9. Submit learnings with `mcp__orgx__submit_learning` and score the artifact with `mcp__orgx__record_quality_score`. +7. Attach proof back to the initiative, task, or decision with `mcp__orgx__orgx_act` (`action=attach`) or `mcp__orgx__orgx_act`. +8. Before every delegation, run `mcp__orgx__orgx_spawn`, then use `mcp__orgx__orgx_spawn`. +9. Submit learnings with `mcp__orgx__orgx_submit_receipt` and score the artifact with `mcp__orgx__orgx_submit_receipt`. Drive multi-agent execution with clear dependencies, quality gates, and accountable handoffs. The orchestrator never does the domain work itself — it coordinates, sequences, unblocks, and synthesizes. @@ -164,21 +164,21 @@ If unknown, state assumptions explicitly and request missing owners or dates. Ne ## Operating Workflow -1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__workspace`. +1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__orgx_bootstrap`. 2. Choose `artifact_type` based on the coordination need. 3. Hydrate the active task or initiative: - - `mcp__orgx__get_task_with_context` for task-bound orchestration work - - `mcp__orgx__list_entities` and `mcp__orgx__get_initiative_pulse` for parent initiative state and neighboring work + - `mcp__orgx__orgx_inspect` for task-bound orchestration work + - `mcp__orgx__orgx_search` and `mcp__orgx__orgx_recommend` for parent initiative state and neighboring work 4. Assess coordination context using the Context Adaptation Protocol. 5. Retrieve learnings and precedent: - - `mcp__orgx__get_relevant_learnings` — past coordination patterns for similar initiatives - - `mcp__orgx__query_org_memory` with `scope: "decisions"` — what worked and failed in prior cross-domain work - - `mcp__orgx__query_org_memory` — organizational precedent and norms + - `mcp__orgx__orgx_search` — past coordination patterns for similar initiatives + - `mcp__orgx__orgx_search` with `scope: "decisions"` — what worked and failed in prior cross-domain work + - `mcp__orgx__orgx_search` — organizational precedent and norms 6. Gather baseline context: - - `mcp__orgx__list_entities` — discover existing initiatives, workstreams, tasks, agents - - `mcp__orgx__get_initiative_pulse` — understand momentum and blockers for in-flight work - - `mcp__orgx__recommend_next_action` — understand current queue pressure before adding new work -7. For new initiative setup, prefer `mcp__orgx__scaffold_initiative` to manual hierarchy assembly. For coordination plans and retrospectives, run a plan session with `mcp__orgx__start_plan_session`, `mcp__orgx__improve_plan`, and `mcp__orgx__record_plan_edit`. + - `mcp__orgx__orgx_search` — discover existing initiatives, workstreams, tasks, agents + - `mcp__orgx__orgx_recommend` — understand momentum and blockers for in-flight work + - `mcp__orgx__orgx_recommend` — understand current queue pressure before adding new work +7. For new initiative setup, prefer `mcp__orgx__orgx_write` to manual hierarchy assembly. For coordination plans and retrospectives, run a plan session with `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, and `mcp__orgx__orgx_plan`. 8. Apply learnings as constraints or calibration adjustments. If a learning says "engineering-agent estimates are consistently 1.5x optimistic," apply that correction factor. 9. Draft JSON-first artifact following the artifact contract. 10. Run the Precision Loop (all 5 passes). @@ -190,18 +190,18 @@ python3 scripts/validate_orchestration.py --type 12. Resolve all failed gates. 13. Execute orchestration: - - Create new initiative hierarchies with `mcp__orgx__scaffold_initiative`, or publish supporting artifacts with `mcp__orgx__create_entity` - - Launch, block, resume, complete, attach evidence, or update state with `mcp__orgx__entity_action` - - Before each delegation, run `mcp__orgx__check_spawn_guard`, then delegate with `mcp__orgx__spawn_agent_task` + - Create new initiative hierarchies with `mcp__orgx__orgx_write`, or publish supporting artifacts with `mcp__orgx__orgx_write` + - Launch, block, resume, complete, attach evidence, or update state with `mcp__orgx__orgx_act` + - Before each delegation, run `mcp__orgx__orgx_spawn`, then delegate with `mcp__orgx__orgx_spawn` - Emit progress checkpoints with `mcp__orgx__orgx_emit_activity` - - Batch state updates with `mcp__orgx__orgx_apply_changeset` (idempotent, transactional) - - Record outcomes with `mcp__orgx__record_outcome` at each milestone + - Batch state updates with `mcp__orgx__orgx_write` (idempotent, transactional) + - Record outcomes with `mcp__orgx__orgx_submit_receipt` at each milestone 14. Attach coordination proof back to OrgX: - - `mcp__orgx__complete_plan` with `attach_to` for planning sessions - - `mcp__orgx__entity_action` with `action=attach` for initiative plans, synthesis, and risk registers - - `mcp__orgx__comment_on_entity` for unblock requests, reviews, and decision notes -15. Submit learnings: `mcp__orgx__submit_learning` with coordination-specific insight. -16. Score the artifact: `mcp__orgx__record_quality_score`. + - `mcp__orgx__orgx_plan` with `attach_to` for planning sessions + - `mcp__orgx__orgx_act` with `action=attach` for initiative plans, synthesis, and risk registers + - `mcp__orgx__orgx_act` for unblock requests, reviews, and decision notes +15. Submit learnings: `mcp__orgx__orgx_submit_receipt` with coordination-specific insight. +16. Score the artifact: `mcp__orgx__orgx_submit_receipt`. ## Artifact Contracts @@ -454,20 +454,20 @@ The orchestrator's effectiveness compounds over time through systematic learning ### Before Orchestrating -1. Call `mcp__orgx__get_relevant_learnings` scoped to the coordination domain and the specific artifact type. Look for patterns like "last quarter's product launch initiative underestimated marketing lead time by 3 weeks" or "engineering-agent estimates for migration work are consistently 1.5x optimistic." -2. Call `mcp__orgx__query_org_memory` with `scope: "decisions"` and a query covering related initiative types. Check for past coordination decisions that worked or failed. +1. Call `mcp__orgx__orgx_search` scoped to the coordination domain and the specific artifact type. Look for patterns like "last quarter's product launch initiative underestimated marketing lead time by 3 weeks" or "engineering-agent estimates for migration work are consistently 1.5x optimistic." +2. Call `mcp__orgx__orgx_search` with `scope: "decisions"` and a query covering related initiative types. Check for past coordination decisions that worked or failed. 3. Apply calibration factors to all estimates. If historical data shows an agent consistently under-estimates or over-estimates, adjust the plan accordingly. Document the calibration factor so it is transparent. ### During Execution -1. Call `mcp__orgx__record_outcome` at each milestone completion. Record both the planned and actual timeline, effort, and quality. This data feeds future calibration. +1. Call `mcp__orgx__orgx_submit_receipt` at each milestone completion. Record both the planned and actual timeline, effort, and quality. This data feeds future calibration. 2. Adjust the remaining plan based on actuals vs estimates. If the first two milestones took 1.5x the estimated time, adjust remaining milestone estimates by 1.5x. 3. Emit progress updates with `mcp__orgx__orgx_emit_activity` at every significant state change so downstream agents and stakeholders have current information. ### After Completion -1. Call `mcp__orgx__submit_learning` with coordination-specific insights. Good learning: "Cross-domain initiatives with shared database dependencies require a dedicated dependency resolution sprint at the start — skipping this added 2 weeks to the critical path." Bad learning: "Coordination is important." -2. Call `mcp__orgx__record_quality_score` per agent contribution with a score and specific rationale. This feeds future agent selection and calibration. +1. Call `mcp__orgx__orgx_submit_receipt` with coordination-specific insights. Good learning: "Cross-domain initiatives with shared database dependencies require a dedicated dependency resolution sprint at the start — skipping this added 2 weeks to the critical path." Bad learning: "Coordination is important." +2. Call `mcp__orgx__orgx_submit_receipt` per agent contribution with a score and specific rationale. This feeds future agent selection and calibration. 3. Produce a retrospective artifact (`--type retro`) for every initiative that spans more than 2 weeks or involves more than 3 agents. ## Precision Loop (Run Every Time) @@ -499,35 +499,35 @@ Run the validator script and confirm zero errors. Verify that all spawned tasks ### Primary - `mcp__orgx__orgx_bootstrap` — initialize OrgX session scope and recommended workflow -- `mcp__orgx__workspace` — resolve workspace scope before orchestration changes -- `mcp__orgx__get_task_with_context` — hydrate task-bound orchestration work with attachments and plan sessions -- `mcp__orgx__query_org_memory` — organizational precedent and context -- `mcp__orgx__list_entities` — discover existing initiatives, workstreams, tasks, agents -- `mcp__orgx__start_plan_session` — open tracked plan sessions for initiative design and retrospectives -- `mcp__orgx__improve_plan` — refine coordination plans using prior patterns -- `mcp__orgx__record_plan_edit` — capture major plan revisions -- `mcp__orgx__complete_plan` — persist and attach the final plan to OrgX entities -- `mcp__orgx__scaffold_initiative` — create initiative hierarchies in one step -- `mcp__orgx__create_entity` — create initiatives, workstreams, milestones, tasks -- `mcp__orgx__entity_action` — launch, complete, or update entity status -- `mcp__orgx__comment_on_entity` — write unblock requests, reviews, and coordination notes -- `mcp__orgx__check_spawn_guard` — verify delegation is allowed before agent spawn -- `mcp__orgx__spawn_agent_task` — delegate work to domain agents +- `mcp__orgx__orgx_bootstrap` — resolve workspace scope before orchestration changes +- `mcp__orgx__orgx_inspect` — hydrate task-bound orchestration work with attachments and plan sessions +- `mcp__orgx__orgx_search` — organizational precedent and context +- `mcp__orgx__orgx_search` — discover existing initiatives, workstreams, tasks, agents +- `mcp__orgx__orgx_plan` — open tracked plan sessions for initiative design and retrospectives +- `mcp__orgx__orgx_plan` — refine coordination plans using prior patterns +- `mcp__orgx__orgx_plan` — capture major plan revisions +- `mcp__orgx__orgx_plan` — persist and attach the final plan to OrgX entities +- `mcp__orgx__orgx_write` — create initiative hierarchies in one step +- `mcp__orgx__orgx_write` — create initiatives, workstreams, milestones, tasks +- `mcp__orgx__orgx_act` — launch, complete, or update entity status +- `mcp__orgx__orgx_act` — write unblock requests, reviews, and coordination notes +- `mcp__orgx__orgx_spawn` — verify delegation is allowed before agent spawn +- `mcp__orgx__orgx_spawn` — delegate work to domain agents - `mcp__orgx__orgx_emit_activity` — emit progress checkpoints and status updates -- `mcp__orgx__orgx_apply_changeset` — batch state updates (idempotent, transactional) -- `mcp__orgx__get_initiative_pulse` — understand initiative momentum and blockers -- `mcp__orgx__get_relevant_learnings` — retrieve past coordination patterns -- `mcp__orgx__query_org_memory` — retrieve prior coordination decisions -- `mcp__orgx__submit_learning` — contribute coordination insights to the flywheel -- `mcp__orgx__record_quality_score` — score artifact and agent contribution quality -- `mcp__orgx__record_outcome` — record milestone outcomes for calibration +- `mcp__orgx__orgx_write` — batch state updates (idempotent, transactional) +- `mcp__orgx__orgx_recommend` — understand initiative momentum and blockers +- `mcp__orgx__orgx_search` — retrieve past coordination patterns +- `mcp__orgx__orgx_search` — retrieve prior coordination decisions +- `mcp__orgx__orgx_submit_receipt` — contribute coordination insights to the flywheel +- `mcp__orgx__orgx_submit_receipt` — score artifact and agent contribution quality +- `mcp__orgx__orgx_submit_receipt` — record milestone outcomes for calibration ### Optional (if configured) - `mcp__linear__list_issues`, `mcp__linear__get_project` — external project management context -- `mcp__orgx__get_org_snapshot` — high-level organizational health -- `mcp__orgx__get_scoring_signals` — prioritization signals for next-up queue -- `mcp__orgx__recommend_next_action` — update prioritization based on coordination signals +- `mcp__orgx__orgx_recommend` — high-level organizational health +- `mcp__orgx__orgx_recommend` — prioritization signals for next-up queue +- `mcp__orgx__orgx_recommend` — update prioritization based on coordination signals ## Failure Handling diff --git a/orchestrator-agent/evaluations/orchestrator-evaluation.json b/orchestrator-agent/evaluations/orchestrator-evaluation.json index 8888a89..629b3a5 100644 --- a/orchestrator-agent/evaluations/orchestrator-evaluation.json +++ b/orchestrator-agent/evaluations/orchestrator-evaluation.json @@ -277,7 +277,7 @@ { "criterion": "learning_submitted", "description": "The retrospective is paired with flywheel learning submission", - "check": "artifact includes reference to submit_learning call or next step to submit coordination learnings", + "check": "artifact includes reference to orgx_submit_receipt call or next step to submit coordination learnings", "weight": 0.8 } ], diff --git a/orchestrator-agent/examples/delegation-message.md b/orchestrator-agent/examples/delegation-message.md index 965077c..49fe006 100644 --- a/orchestrator-agent/examples/delegation-message.md +++ b/orchestrator-agent/examples/delegation-message.md @@ -124,8 +124,8 @@ This is a worked example of a delegation message from the orchestrator to the en ] }, "handoff": { - "output_format": "RFC (for API design review at checkpoint 1) + deployed staging environment (at checkpoint 2) + production deployment with monitoring (at deadline). All artifacts published via mcp__orgx__create_entity linked to init-analytics-dash-001.", - "completion_signal": "Call mcp__orgx__entity_action to mark workstream ws-engineering as complete. Include artifact references for RFC, staging URL, production deployment confirmation, and monitoring dashboard URL." + "output_format": "RFC (for API design review at checkpoint 1) + deployed staging environment (at checkpoint 2) + production deployment with monitoring (at deadline). All artifacts published via mcp__orgx__orgx_write linked to init-analytics-dash-001.", + "completion_signal": "Call mcp__orgx__orgx_act to mark workstream ws-engineering as complete. Include artifact references for RFC, staging URL, production deployment confirmation, and monitoring dashboard URL." } } ``` diff --git a/orchestrator-agent/skill.toml b/orchestrator-agent/skill.toml index 70a00e3..1d6f26b 100644 --- a/orchestrator-agent/skill.toml +++ b/orchestrator-agent/skill.toml @@ -2,6 +2,6 @@ name = "orchestrator-agent" version = "2.0.0" description = "Coordinate high-confidence cross-domain execution in OrgX by creating initiatives, delegating to domain agents, and synthesizing outputs. Produces initiative plans, delegation messages, synthesis reports, retrospectives, dependency audits, resource allocations, risk registers, stakeholder updates, and program status reports. Use when work spans multiple teams or requires explicit dependency, sequencing, and quality coordination." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_task_with_context", "mcp__orgx__query_org_memory", "mcp__orgx__list_entities", "mcp__orgx__start_plan_session", "mcp__orgx__improve_plan", "mcp__orgx__record_plan_edit", "mcp__orgx__complete_plan", "mcp__orgx__scaffold_initiative", "mcp__orgx__create_entity", "mcp__orgx__entity_action", "mcp__orgx__comment_on_entity", "mcp__orgx__check_spawn_guard", "mcp__orgx__get_initiative_pulse", "mcp__orgx__get_relevant_learnings", "mcp__orgx__orgx_apply_changeset", "mcp__orgx__orgx_emit_activity", "mcp__orgx__record_outcome", "mcp__orgx__record_quality_score", "mcp__orgx__recommend_next_action", "mcp__orgx__spawn_agent_task", "mcp__orgx__submit_learning"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_write", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_search", "mcp__orgx__orgx_write", "mcp__orgx__orgx_emit_activity", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_recommend", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_submit_receipt"] required_scopes = [] resources = ["examples/initiative-plan.md", "examples/delegation-message.md", "reference/orchestration-frameworks-cheatsheet.md", "reference/delegation-template.md", "reference/raci-template.md", "evaluations/orchestrator-evaluation.json"] diff --git a/product-agent/SKILL.md b/product-agent/SKILL.md index 8010d2e..fb44d31 100644 --- a/product-agent/SKILL.md +++ b/product-agent/SKILL.md @@ -10,17 +10,17 @@ description: | ## Quick Start -1. Run `mcp__orgx__orgx_bootstrap`, then resolve the active workspace with `mcp__orgx__workspace`. -2. Confirm the artifact type (`--type`) and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__get_task_with_context`; otherwise pull surrounding context with `mcp__orgx__list_entities`. -3. Pull precedent with `mcp__orgx__query_org_memory` and `mcp__orgx__get_relevant_learnings`. -4. If the output is a plan, start a planning loop with `mcp__orgx__start_plan_session`, refine with `mcp__orgx__improve_plan`, record material revisions with `mcp__orgx__record_plan_edit`, and close it with `mcp__orgx__complete_plan` using `attach_to`. +1. Run `mcp__orgx__orgx_bootstrap`, then resolve the active workspace with `mcp__orgx__orgx_bootstrap`. +2. Confirm the artifact type (`--type`) and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__orgx_inspect`; otherwise pull surrounding context with `mcp__orgx__orgx_search`. +3. Pull precedent with `mcp__orgx__orgx_search` and `mcp__orgx__orgx_search`. +4. If the output is a plan, start a planning loop with `mcp__orgx__orgx_plan`, refine with `mcp__orgx__orgx_plan`, record material revisions with `mcp__orgx__orgx_plan`, and close it with `mcp__orgx__orgx_plan` using `attach_to`. 5. Produce the artifact using the contract below and return: - A concise summary (3-6 bullets) - The artifact body (JSON or structured Markdown) - 3 actionable next steps with owners 6. Validate with `python3 scripts/validate_artifact.py --type `. -7. Publish via `mcp__orgx__create_entity`, attach evidence back to the task or initiative with `mcp__orgx__entity_action` (`action=attach`) or `mcp__orgx__comment_on_entity`, and record quality via `mcp__orgx__record_quality_score`. -8. Before delegating follow-on execution, run `mcp__orgx__check_spawn_guard`, then use `mcp__orgx__spawn_agent_task`. +7. Publish via `mcp__orgx__orgx_write`, attach evidence back to the task or initiative with `mcp__orgx__orgx_act` (`action=attach`) or `mcp__orgx__orgx_act`, and record quality via `mcp__orgx__orgx_submit_receipt`. +8. Before delegating follow-on execution, run `mcp__orgx__orgx_spawn`, then use `mcp__orgx__orgx_spawn`. Create product artifacts that are decision-ready, measurable, and execution-aligned. @@ -339,34 +339,34 @@ A handoff without all five elements is incomplete. The agent must flag missing e Before producing any artifact, the agent must: -1. Call `mcp__orgx__get_relevant_learnings` with the product domain and artifact type as context. Apply returned learnings as constraints, confidence adjustments, or explicit references in the artifact. -2. Call `mcp__orgx__query_org_memory` with `scope: "decisions"` for related product decisions. Check for prior decisions that constrain or inform the current artifact. Reference them explicitly. -3. If the artifact relates to an existing initiative, call `mcp__orgx__get_initiative_pulse` to understand current momentum and blockers. +1. Call `mcp__orgx__orgx_search` with the product domain and artifact type as context. Apply returned learnings as constraints, confidence adjustments, or explicit references in the artifact. +2. Call `mcp__orgx__orgx_search` with `scope: "decisions"` for related product decisions. Check for prior decisions that constrain or inform the current artifact. Reference them explicitly. +3. If the artifact relates to an existing initiative, call `mcp__orgx__orgx_recommend` to understand current momentum and blockers. ### After Completion After every artifact is finalized and published: -1. Call `mcp__orgx__submit_learning` with an outcome-linked insight. Format: "When building [artifact type] for [context], we learned [insight] because [evidence]. This should inform future [artifact types] by [specific guidance]." -2. Call `mcp__orgx__record_quality_score` on the artifact with a self-assessed quality score and justification. -3. If the artifact reveals a gap in organizational knowledge, call `mcp__orgx__spawn_agent_task` to assign follow-up research. +1. Call `mcp__orgx__orgx_submit_receipt` with an outcome-linked insight. Format: "When building [artifact type] for [context], we learned [insight] because [evidence]. This should inform future [artifact types] by [specific guidance]." +2. Call `mcp__orgx__orgx_submit_receipt` on the artifact with a self-assessed quality score and justification. +3. If the artifact reveals a gap in organizational knowledge, call `mcp__orgx__orgx_spawn` to assign follow-up research. --- ## Operating Workflow -1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__workspace`. +1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__orgx_bootstrap`. 2. Select `artifact_type` and confirm decision scope with the requester. 3. Hydrate the active task or parent entity: - - Use `mcp__orgx__get_task_with_context` for task-bound work - - Use `mcp__orgx__list_entities` for nearby initiatives, milestones, workstreams, or prior artifacts + - Use `mcp__orgx__orgx_inspect` for task-bound work + - Use `mcp__orgx__orgx_search` for nearby initiatives, milestones, workstreams, or prior artifacts 4. Run Context Adaptation Protocol and detect the product stage. 5. Gather evidence: - - OrgX context: `mcp__orgx__query_org_memory`, `mcp__orgx__list_entities` - - Flywheel learnings: `mcp__orgx__get_relevant_learnings`, `mcp__orgx__query_org_memory` with `scope: "decisions"` + - OrgX context: `mcp__orgx__orgx_search`, `mcp__orgx__orgx_search` + - Flywheel learnings: `mcp__orgx__orgx_search`, `mcp__orgx__orgx_search` with `scope: "decisions"` - Work planning context: `mcp__linear__*` when available - User signal context: `mcp__intercom__search` when available -6. For planning-heavy outputs, open a plan session with `mcp__orgx__start_plan_session`, iterate with `mcp__orgx__improve_plan`, and record substantive edits with `mcp__orgx__record_plan_edit`. +6. For planning-heavy outputs, open a plan session with `mcp__orgx__orgx_plan`, iterate with `mcp__orgx__orgx_plan`, and record substantive edits with `mcp__orgx__orgx_plan`. 7. Draft JSON-first artifact applying the Domain Expertise Canon. 8. Run the Precision Loop (see below). 9. Validate: @@ -376,14 +376,14 @@ python3 scripts/validate_artifact.py --type ``` 10. Resolve all validator errors. -11. Publish via `mcp__orgx__create_entity`. +11. Publish via `mcp__orgx__orgx_write`. 12. Attach proof or summaries back to the triggering entity: - - `mcp__orgx__complete_plan` with `attach_to` for plan-session outputs - - `mcp__orgx__entity_action` with `action=attach` for artifacts, research notes, and handoff docs - - `mcp__orgx__comment_on_entity` for review notes or decision annotations -13. Record quality via `mcp__orgx__record_quality_score`. -14. Submit learnings via `mcp__orgx__submit_learning`. -15. Before delegating implementation or research, run `mcp__orgx__check_spawn_guard`, then use `mcp__orgx__spawn_agent_task`. + - `mcp__orgx__orgx_plan` with `attach_to` for plan-session outputs + - `mcp__orgx__orgx_act` with `action=attach` for artifacts, research notes, and handoff docs + - `mcp__orgx__orgx_act` for review notes or decision annotations +13. Record quality via `mcp__orgx__orgx_submit_receipt`. +14. Submit learnings via `mcp__orgx__orgx_submit_receipt`. +15. Before delegating implementation or research, run `mcp__orgx__orgx_spawn`, then use `mcp__orgx__orgx_spawn`. --- @@ -402,23 +402,23 @@ python3 scripts/validate_artifact.py --type ### Primary - `mcp__orgx__orgx_bootstrap` — initialize the current OrgX session and recommended workflow -- `mcp__orgx__workspace` — resolve or switch workspace scope before reading or writing -- `mcp__orgx__get_task_with_context` — hydrate task-bound context attachments and prior plan sessions -- `mcp__orgx__query_org_memory` — retrieve organizational context and prior decisions -- `mcp__orgx__list_entities` — discover existing initiatives, workstreams, tasks -- `mcp__orgx__start_plan_session` — open a tracked planning session for plan-shaped work -- `mcp__orgx__improve_plan` — refine a draft plan using historical patterns -- `mcp__orgx__record_plan_edit` — log significant planning revisions -- `mcp__orgx__complete_plan` — persist the final plan and attach it to OrgX entities -- `mcp__orgx__create_entity` — publish completed artifacts -- `mcp__orgx__entity_action` — update entity status and properties -- `mcp__orgx__comment_on_entity` — leave review notes on the active task or initiative -- `mcp__orgx__check_spawn_guard` — verify delegation is allowed before spawning follow-on work -- `mcp__orgx__spawn_agent_task` — assign follow-up work to other agents -- `mcp__orgx__get_relevant_learnings` — retrieve flywheel learnings for context -- `mcp__orgx__submit_learning` — record new learnings -- `mcp__orgx__record_quality_score` — record artifact quality assessment -- `mcp__orgx__get_initiative_pulse` — understand initiative momentum +- `mcp__orgx__orgx_bootstrap` — resolve or switch workspace scope before reading or writing +- `mcp__orgx__orgx_inspect` — hydrate task-bound context attachments and prior plan sessions +- `mcp__orgx__orgx_search` — retrieve organizational context and prior decisions +- `mcp__orgx__orgx_search` — discover existing initiatives, workstreams, tasks +- `mcp__orgx__orgx_plan` — open a tracked planning session for plan-shaped work +- `mcp__orgx__orgx_plan` — refine a draft plan using historical patterns +- `mcp__orgx__orgx_plan` — log significant planning revisions +- `mcp__orgx__orgx_plan` — persist the final plan and attach it to OrgX entities +- `mcp__orgx__orgx_write` — publish completed artifacts +- `mcp__orgx__orgx_act` — update entity status and properties +- `mcp__orgx__orgx_act` — leave review notes on the active task or initiative +- `mcp__orgx__orgx_spawn` — verify delegation is allowed before spawning follow-on work +- `mcp__orgx__orgx_spawn` — assign follow-up work to other agents +- `mcp__orgx__orgx_search` — retrieve flywheel learnings for context +- `mcp__orgx__orgx_submit_receipt` — record new learnings +- `mcp__orgx__orgx_submit_receipt` — record artifact quality assessment +- `mcp__orgx__orgx_recommend` — understand initiative momentum ### Optional (if configured) diff --git a/product-agent/skill.toml b/product-agent/skill.toml index 189c0b0..ab9a6ce 100644 --- a/product-agent/skill.toml +++ b/product-agent/skill.toml @@ -2,6 +2,6 @@ name = "product-agent" version = "2.0.0" description = "Produce high-confidence product artifacts for OrgX: PRDs, initiative plans, product canvases, user research briefs, competitive analyses, feature prioritization matrices, pivot evaluations, metric dashboard specs, and launch readiness checklists. Use when problem framing, user/value articulation, prioritization, and measurable product outcomes are required." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_task_with_context", "mcp__orgx__query_org_memory", "mcp__orgx__list_entities", "mcp__orgx__start_plan_session", "mcp__orgx__improve_plan", "mcp__orgx__record_plan_edit", "mcp__orgx__complete_plan", "mcp__orgx__create_entity", "mcp__orgx__entity_action", "mcp__orgx__comment_on_entity", "mcp__orgx__check_spawn_guard", "mcp__orgx__spawn_agent_task", "mcp__orgx__get_relevant_learnings", "mcp__orgx__submit_learning", "mcp__orgx__record_quality_score", "mcp__orgx__get_initiative_pulse"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_search", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_recommend"] required_scopes = [] resources = [] diff --git a/sales-agent/SKILL.md b/sales-agent/SKILL.md index d0912bb..f4ec303 100644 --- a/sales-agent/SKILL.md +++ b/sales-agent/SKILL.md @@ -10,17 +10,17 @@ description: | ## Quick Start -1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__workspace`. -2. Confirm the artifact or decision type and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__get_task_with_context`; otherwise map related deal work with `mcp__orgx__list_entities`. -3. Pull precedent with `mcp__orgx__query_org_memory` and `mcp__orgx__get_relevant_learnings`. -4. For deal plans, QBRs, or territory programs, use the planning loop: `mcp__orgx__start_plan_session`, `mcp__orgx__improve_plan`, `mcp__orgx__record_plan_edit`, then `mcp__orgx__complete_plan`. +1. Run `mcp__orgx__orgx_bootstrap`, then resolve workspace scope with `mcp__orgx__orgx_bootstrap`. +2. Confirm the artifact or decision type and the target audience. If the request is task-bound, hydrate it with `mcp__orgx__orgx_inspect`; otherwise map related deal work with `mcp__orgx__orgx_search`. +3. Pull precedent with `mcp__orgx__orgx_search` and `mcp__orgx__orgx_search`. +4. For deal plans, QBRs, or territory programs, use the planning loop: `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, `mcp__orgx__orgx_plan`, then `mcp__orgx__orgx_plan`. 5. Adapt behavior to deal segment and motion using the Context Adaptation Protocol below. 6. Produce the artifact using the contract below and return: - A concise summary (3-6 bullets) - The artifact body (JSON or structured Markdown) - 3 actionable next steps with owners and dates 7. Run the Precision Loop before finalizing. -8. Attach the result back to the active work with `mcp__orgx__entity_action` (`action=attach`) or `mcp__orgx__comment_on_entity`, then record quality with `mcp__orgx__record_quality_score`. +8. Attach the result back to the active work with `mcp__orgx__orgx_act` (`action=attach`) or `mcp__orgx__orgx_act`, then record quality with `mcp__orgx__orgx_submit_receipt`. Create revenue-focused sales artifacts that are specific, evidence-backed, and execution-ready. Every claim must have proof or an explicit confidence level. Every action must have an owner. @@ -396,7 +396,7 @@ The sales agent improves over time by recording and consuming organizational lea ### Record After Every Artifact -After producing any artifact, record learnings via `mcp__orgx__submit_learning`: +After producing any artifact, record learnings via `mcp__orgx__orgx_submit_receipt`: - **Win/Loss patterns**: Winning talk tracks, objections that killed deals, competitor tactics observed. - **Pricing feedback**: What price points got pushback, what discounting worked, where we left money on the table. @@ -405,7 +405,7 @@ After producing any artifact, record learnings via `mcp__orgx__submit_learning`: ### Consume Before Every Artifact -Before producing any artifact, query learnings via `mcp__orgx__get_relevant_learnings`: +Before producing any artifact, query learnings via `mcp__orgx__orgx_search`: - Pull win/loss data for the same segment, competitor, or deal size. - Pull objection handling that worked in similar deals. @@ -422,17 +422,17 @@ Before producing any artifact, query learnings via `mcp__orgx__get_relevant_lear ## Operating Workflow -1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__workspace`. +1. Run `mcp__orgx__orgx_bootstrap` and resolve workspace with `mcp__orgx__orgx_bootstrap`. 2. Select `artifact_type`. 3. Hydrate the active task or deal context: - - `mcp__orgx__get_task_with_context` for task-bound sales work - - `mcp__orgx__list_entities` for related initiatives, prior proposals, and deal artifacts + - `mcp__orgx__orgx_inspect` for task-bound sales work + - `mcp__orgx__orgx_search` for related initiatives, prior proposals, and deal artifacts 4. Run Context Adaptation Protocol to determine segment, motion, and complexity level. 5. Gather evidence: - - OrgX historical context via `mcp__orgx__query_org_memory` - - Recent learnings via `mcp__orgx__get_relevant_learnings` + - OrgX historical context via `mcp__orgx__orgx_search` + - Recent learnings via `mcp__orgx__orgx_search` - CRM/call context via `mcp__salesforce__*` and `mcp__gong__*` when available -6. For sequences, account plans, or QBRs, open a plan session with `mcp__orgx__start_plan_session`, refine with `mcp__orgx__improve_plan`, and record substantive revisions with `mcp__orgx__record_plan_edit`. +6. For sequences, account plans, or QBRs, open a plan session with `mcp__orgx__orgx_plan`, refine with `mcp__orgx__orgx_plan`, and record substantive revisions with `mcp__orgx__orgx_plan`. 7. Apply relevant frameworks from the Domain Expertise Canon. 8. Draft JSON-first artifact per the contract above. 9. Run Precision Loop (below). @@ -442,14 +442,14 @@ Before producing any artifact, query learnings via `mcp__orgx__get_relevant_lear python3 scripts/validate_sales.py --type ``` -11. Resolve all validator errors and publish with `mcp__orgx__create_entity`. +11. Resolve all validator errors and publish with `mcp__orgx__orgx_write`. 12. Attach proof or conclusions back to the active work: - - `mcp__orgx__complete_plan` with `attach_to` for plan sessions - - `mcp__orgx__entity_action` with `action=attach` for battlecards, sequences, and pricing docs - - `mcp__orgx__comment_on_entity` for coaching notes and decision annotations -13. Record learnings via `mcp__orgx__submit_learning`. -14. Record artifact quality via `mcp__orgx__record_quality_score`. -15. Before delegating prospecting or follow-up work, run `mcp__orgx__check_spawn_guard`, then use `mcp__orgx__spawn_agent_task`. + - `mcp__orgx__orgx_plan` with `attach_to` for plan sessions + - `mcp__orgx__orgx_act` with `action=attach` for battlecards, sequences, and pricing docs + - `mcp__orgx__orgx_act` for coaching notes and decision annotations +13. Record learnings via `mcp__orgx__orgx_submit_receipt`. +14. Record artifact quality via `mcp__orgx__orgx_submit_receipt`. +15. Before delegating prospecting or follow-up work, run `mcp__orgx__orgx_spawn`, then use `mcp__orgx__orgx_spawn`. --- @@ -487,23 +487,23 @@ Every artifact must pass all four passes before delivery. Primary: - `mcp__orgx__orgx_bootstrap` -- initialize OrgX session scope and recommended workflow -- `mcp__orgx__workspace` -- resolve or switch workspace scope -- `mcp__orgx__get_task_with_context` -- hydrate task-bound context, attachments, and plan sessions -- `mcp__orgx__query_org_memory` -- pull deal history, past artifacts, org context -- `mcp__orgx__list_entities` -- list existing deals, initiatives, tasks -- `mcp__orgx__start_plan_session` -- open tracked planning sessions for sequences, QBRs, and territory plans -- `mcp__orgx__improve_plan` -- refine sales plans with historical patterns -- `mcp__orgx__record_plan_edit` -- capture major planning revisions -- `mcp__orgx__complete_plan` -- finalize and attach the plan to OrgX entities -- `mcp__orgx__create_entity` -- publish completed artifacts -- `mcp__orgx__entity_action` -- attach evidence and update entity state -- `mcp__orgx__comment_on_entity` -- leave coaching notes and deal annotations on active work -- `mcp__orgx__check_spawn_guard` -- verify delegation is allowed before handoff -- `mcp__orgx__spawn_agent_task` -- delegate sub-tasks to other agents -- `mcp__orgx__submit_learning` -- record deal learnings for the flywheel -- `mcp__orgx__get_relevant_learnings` -- pull learnings from past deals -- `mcp__orgx__record_quality_score` -- record artifact quality for calibration -- `mcp__orgx__get_org_snapshot` -- understand current org state and priorities +- `mcp__orgx__orgx_bootstrap` -- resolve or switch workspace scope +- `mcp__orgx__orgx_inspect` -- hydrate task-bound context, attachments, and plan sessions +- `mcp__orgx__orgx_search` -- pull deal history, past artifacts, org context +- `mcp__orgx__orgx_search` -- list existing deals, initiatives, tasks +- `mcp__orgx__orgx_plan` -- open tracked planning sessions for sequences, QBRs, and territory plans +- `mcp__orgx__orgx_plan` -- refine sales plans with historical patterns +- `mcp__orgx__orgx_plan` -- capture major planning revisions +- `mcp__orgx__orgx_plan` -- finalize and attach the plan to OrgX entities +- `mcp__orgx__orgx_write` -- publish completed artifacts +- `mcp__orgx__orgx_act` -- attach evidence and update entity state +- `mcp__orgx__orgx_act` -- leave coaching notes and deal annotations on active work +- `mcp__orgx__orgx_spawn` -- verify delegation is allowed before handoff +- `mcp__orgx__orgx_spawn` -- delegate sub-tasks to other agents +- `mcp__orgx__orgx_submit_receipt` -- record deal learnings for the flywheel +- `mcp__orgx__orgx_search` -- pull learnings from past deals +- `mcp__orgx__orgx_submit_receipt` -- record artifact quality for calibration +- `mcp__orgx__orgx_recommend` -- understand current org state and priorities Optional (if configured): diff --git a/sales-agent/skill.toml b/sales-agent/skill.toml index 47dd7db..6fa3f72 100644 --- a/sales-agent/skill.toml +++ b/sales-agent/skill.toml @@ -2,6 +2,6 @@ name = "sales-agent" version = "2.0.0" description = "Produce high-confidence sales artifacts for OrgX: competitive battlecards, MEDDIC deal scorecards, and outreach sequences. Use when deal qualification, competitive positioning, stakeholder persuasion, or revenue-risk reduction is needed." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_task_with_context", "mcp__orgx__query_org_memory", "mcp__orgx__list_entities", "mcp__orgx__get_relevant_learnings", "mcp__orgx__start_plan_session", "mcp__orgx__improve_plan", "mcp__orgx__record_plan_edit", "mcp__orgx__complete_plan", "mcp__orgx__create_entity", "mcp__orgx__entity_action", "mcp__orgx__comment_on_entity", "mcp__orgx__check_spawn_guard", "mcp__orgx__spawn_agent_task", "mcp__orgx__submit_learning", "mcp__orgx__record_quality_score", "mcp__orgx__get_org_snapshot"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_search", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_submit_receipt", "mcp__orgx__orgx_recommend"] required_scopes = [] resources = [] diff --git a/scripts/check_skill_tool_drift.py b/scripts/check_skill_tool_drift.py index b35df96..6d3cb9e 100644 --- a/scripts/check_skill_tool_drift.py +++ b/scripts/check_skill_tool_drift.py @@ -17,16 +17,31 @@ STRING_RE = re.compile(r'"([^"]+)"') KNOWN_ORGX_TOOLS = { + "orgx_act", + "orgx_attach", + "orgx_bootstrap", + "orgx_decide", + "orgx_emit_activity", + "orgx_inspect", + "orgx_plan", + "orgx_recommend", + "orgx_search", + "orgx_spawn", + "orgx_submit_receipt", + "orgx_write", +} + +DEPRECATED_ORGX_TOOLS = { "account_status", "account_upgrade", "account_usage_report", "approve_decision", "batch_action", - "batch_create_entities", "batch_delete_entities", - "check_spawn_guard", + "batch_create_entities", "classify_task_model", - "comment_on_entity", + "check_spawn_guard", + "complete_entity", "complete_plan", "configure_org", "create_decision", @@ -49,13 +64,10 @@ "get_task_with_context", "handoff_task", "improve_plan", - "list_entities", + "launch_entity", "list_entity_comments", - "orgx_apply_changeset", - "orgx_bootstrap", - "orgx_describe_action", - "orgx_describe_tool", - "orgx_emit_activity", + "list_entities", + "pause_entity", "pin_workstream", "query_org_memory", "queue_action", @@ -65,7 +77,7 @@ "record_quality_score", "reject_decision", "resume_plan_session", - "scaffold_initiative", + "save_artifact", "score_next_up_queue", "scoring_config", "spawn_agent_task", @@ -78,19 +90,9 @@ "update_stream_progress", "validate_studio_content", "verify_entity_completion", - "workspace", } -DEPRECATED_ORGX_TOOLS = { - "complete_entity", - "get_decision_history", - "get_pending_decisions", - "launch_entity", - "pause_entity", - "score_next_up_queue", -} - -PLAN_TOOLS = {"start_plan_session", "improve_plan", "record_plan_edit"} +PLAN_TOOLS = {"orgx_plan"} def read_text(path: Path) -> str: @@ -138,25 +140,13 @@ def main() -> int: if not combined_refs: continue - missing_baseline = {"orgx_bootstrap", "workspace"} - combined_refs + missing_baseline = {"orgx_bootstrap"} - combined_refs for tool in sorted(missing_baseline): errors.append( f"{skill_dir.name} is missing baseline OrgX workflow tool " f"`mcp__orgx__{tool}` in its skill files" ) - if "spawn_agent_task" in combined_refs and "check_spawn_guard" not in combined_refs: - errors.append( - f"{skill_dir.name} references `mcp__orgx__spawn_agent_task` without " - f"`mcp__orgx__check_spawn_guard`" - ) - - if combined_refs & PLAN_TOOLS and "complete_plan" not in combined_refs: - errors.append( - f"{skill_dir.name} references plan-session tools without " - f"`mcp__orgx__complete_plan`" - ) - skill_toml = skill_dir / "skill.toml" if skill_toml.exists(): required_tools = set(parse_required_tools(skill_toml)) @@ -166,24 +156,12 @@ def main() -> int: if tool.startswith("mcp__orgx__") } - for tool in sorted({"orgx_bootstrap", "workspace"} - orgx_required): + for tool in sorted({"orgx_bootstrap"} - orgx_required): errors.append( f"{skill_toml.relative_to(ROOT)} is missing required tool " f"`mcp__orgx__{tool}`" ) - if "spawn_agent_task" in orgx_required and "check_spawn_guard" not in orgx_required: - errors.append( - f"{skill_toml.relative_to(ROOT)} declares `mcp__orgx__spawn_agent_task` " - f"without `mcp__orgx__check_spawn_guard`" - ) - - if orgx_required & PLAN_TOOLS and "complete_plan" not in orgx_required: - errors.append( - f"{skill_toml.relative_to(ROOT)} declares plan-session tools without " - f"`mcp__orgx__complete_plan`" - ) - for tool in sorted(orgx_required): if tool in DEPRECATED_ORGX_TOOLS: errors.append( diff --git a/task-protocol/SKILL.md b/task-protocol/SKILL.md index 1a26913..1e3bf3a 100644 --- a/task-protocol/SKILL.md +++ b/task-protocol/SKILL.md @@ -13,10 +13,10 @@ description: | ## Starting a Task - Bootstrap with `mcp__orgx__orgx_bootstrap`. -- Confirm or set workspace through `mcp__orgx__workspace`. -- Read the task with `mcp__orgx__get_task_with_context`. -- If you only have an entity ID, use `mcp__orgx__list_entities` with `id` and `hydrate_context=true`. -- Start with `mcp__orgx__entity_action type=task action=launch`. +- Confirm or set workspace through `mcp__orgx__orgx_bootstrap`. +- Read the task with `mcp__orgx__orgx_inspect`. +- If you only have an entity ID, use `mcp__orgx__orgx_search` with `id` and `hydrate_context=true`. +- Start with `mcp__orgx__orgx_act type=task action=launch`. - Emit kickoff telemetry with `mcp__orgx__orgx_emit_activity phase=intent`. - Verify prerequisites, context attachments, and acceptance criteria before doing work. @@ -24,35 +24,35 @@ description: | - Follow the domain-specific workflow from the active skill. - Emit progress with `mcp__orgx__orgx_emit_activity` at meaningful milestones. -- Use `mcp__orgx__entity_action action=attach` to link docs, URLs, plans, PRs, screenshots, or other proof back to the task. +- Use `mcp__orgx__orgx_act action=attach` to link docs, URLs, plans, PRs, screenshots, or other proof back to the task. - If the work starts as planning, run: - - `mcp__orgx__start_plan_session` - - `mcp__orgx__improve_plan` - - `mcp__orgx__record_plan_edit` for major revisions - - `mcp__orgx__complete_plan attach_to=[{ entity_type: "task", entity_id: ... }]` + - `mcp__orgx__orgx_plan` + - `mcp__orgx__orgx_plan` + - `mcp__orgx__orgx_plan` for major revisions + - `mcp__orgx__orgx_plan attach_to=[{ entity_type: "task", entity_id: ... }]` ## Handling Blockers -- Pause with `mcp__orgx__entity_action type=task action=pause note="..."`. -- Document the blocker clearly with `mcp__orgx__comment_on_entity`. +- Pause with `mcp__orgx__orgx_act type=task action=pause note="..."`. +- Document the blocker clearly with `mcp__orgx__orgx_act`. - Emit blocker telemetry with `mcp__orgx__orgx_emit_activity phase=blocked`. - When the blocker needs an explicit approval, tradeoff, or de-stall decision, - create it through `mcp__orgx__orgx_apply_changeset` with a `decision.create` + create it through `mcp__orgx__orgx_write` with a `decision.create` operation and an idempotency key tied to the task/run. -- Before cross-domain delegation, call `mcp__orgx__check_spawn_guard`. -- Use `mcp__orgx__spawn_agent_task` or `mcp__orgx__handoff_task` only after the guard passes. +- Before cross-domain delegation, call `mcp__orgx__orgx_spawn`. +- Use `mcp__orgx__orgx_spawn` or `mcp__orgx__orgx_spawn` only after the guard passes. ## Completing - Validate output against acceptance criteria. - Run domain-specific quality gates. -- Verify readiness with `mcp__orgx__verify_entity_completion type=task`. +- Verify readiness with `mcp__orgx__orgx_act type=task`. - Attach final proof if anything is still only in the transcript. - Batch any final task, milestone, or decision state updates through - `mcp__orgx__orgx_apply_changeset` when more than one state mutation is + `mcp__orgx__orgx_write` when more than one state mutation is required. - Emit final telemetry with `mcp__orgx__orgx_emit_activity phase=completed progress_pct=100`. -- Complete with `mcp__orgx__entity_action type=task action=complete`. +- Complete with `mcp__orgx__orgx_act type=task action=complete`. ## Task Types diff --git a/task-protocol/skill.toml b/task-protocol/skill.toml index 1c9cdee..9ae2621 100644 --- a/task-protocol/skill.toml +++ b/task-protocol/skill.toml @@ -2,6 +2,6 @@ name = "task-protocol" version = "2.0.0" description = "Individual task execution protocol for OrgX with context hydration, plan-session handoff, evidence attachment, guarded delegation, and completion verification." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__get_task_with_context", "mcp__orgx__list_entities", "mcp__orgx__entity_action", "mcp__orgx__orgx_emit_activity", "mcp__orgx__orgx_apply_changeset", "mcp__orgx__comment_on_entity", "mcp__orgx__check_spawn_guard", "mcp__orgx__spawn_agent_task", "mcp__orgx__handoff_task", "mcp__orgx__verify_entity_completion", "mcp__orgx__start_plan_session", "mcp__orgx__improve_plan", "mcp__orgx__record_plan_edit", "mcp__orgx__complete_plan"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_search", "mcp__orgx__orgx_act", "mcp__orgx__orgx_emit_activity", "mcp__orgx__orgx_write", "mcp__orgx__orgx_act", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_act", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan", "mcp__orgx__orgx_plan"] required_scopes = [] resources = [] diff --git a/workstream-protocol/SKILL.md b/workstream-protocol/SKILL.md index fe6457e..4fe4386 100644 --- a/workstream-protocol/SKILL.md +++ b/workstream-protocol/SKILL.md @@ -15,11 +15,11 @@ description: | ### 1. Initialize - Bootstrap with `mcp__orgx__orgx_bootstrap`. -- Confirm or set workspace through `mcp__orgx__workspace`. -- Read the stream with `mcp__orgx__list_entities type=stream`. -- Check upstream and downstream pressure with `mcp__orgx__get_initiative_stream_state`. -- If the stream is ready to start, use `mcp__orgx__entity_action type=stream action=launch`. -- Report 0% progress via `mcp__orgx__update_stream_progress`. +- Confirm or set workspace through `mcp__orgx__orgx_bootstrap`. +- Read the stream with `mcp__orgx__orgx_search type=stream`. +- Check upstream and downstream pressure with `mcp__orgx__orgx_inspect`. +- If the stream is ready to start, use `mcp__orgx__orgx_act type=stream action=launch`. +- Report 0% progress via `mcp__orgx__orgx_emit_activity`. ### 2. Execute @@ -28,21 +28,21 @@ description: | - Progress and confidence are separate: - `progress_pct`: how much work is done - `confidence`: how confident you are in the current output -- Attach important outputs to the stream or its tasks with `mcp__orgx__entity_action action=attach`. +- Attach important outputs to the stream or its tasks with `mcp__orgx__orgx_act action=attach`. ### 3. Handle Blockers -- Pause or block with `mcp__orgx__entity_action type=stream action=pause note="..."`. -- Use `mcp__orgx__comment_on_entity` for detailed blocker context. -- Before delegating new work, call `mcp__orgx__check_spawn_guard`. -- Use `mcp__orgx__spawn_agent_task` or `mcp__orgx__handoff_task` only after the guard passes. +- Pause or block with `mcp__orgx__orgx_act type=stream action=pause note="..."`. +- Use `mcp__orgx__orgx_act` for detailed blocker context. +- Before delegating new work, call `mcp__orgx__orgx_spawn`. +- Use `mcp__orgx__orgx_spawn` or `mcp__orgx__orgx_spawn` only after the guard passes. ### 4. Complete - Run domain-specific validation. -- Verify readiness with `mcp__orgx__verify_entity_completion type=workstream`. -- Complete with `mcp__orgx__entity_action type=stream action=complete`. -- Downstream streams should move because the DAG is now unblocked; verify with `mcp__orgx__get_initiative_stream_state`. +- Verify readiness with `mcp__orgx__orgx_act type=workstream`. +- Complete with `mcp__orgx__orgx_act type=stream action=complete`. +- Downstream streams should move because the DAG is now unblocked; verify with `mcp__orgx__orgx_inspect`. ### 5. Error Handling diff --git a/workstream-protocol/skill.toml b/workstream-protocol/skill.toml index 2151cd8..13af310 100644 --- a/workstream-protocol/skill.toml +++ b/workstream-protocol/skill.toml @@ -2,6 +2,6 @@ name = "workstream-protocol" version = "2.0.0" description = "Stream execution lifecycle for OrgX workstreams with DAG-aware monitoring, evidence attachment, guarded delegation, and completion verification." entry_instructions = "SKILL.md" -required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__workspace", "mcp__orgx__entity_action", "mcp__orgx__get_initiative_stream_state", "mcp__orgx__list_entities", "mcp__orgx__check_spawn_guard", "mcp__orgx__spawn_agent_task", "mcp__orgx__handoff_task", "mcp__orgx__update_stream_progress", "mcp__orgx__verify_entity_completion", "mcp__orgx__comment_on_entity"] +required_tools = ["mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_bootstrap", "mcp__orgx__orgx_act", "mcp__orgx__orgx_inspect", "mcp__orgx__orgx_search", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_spawn", "mcp__orgx__orgx_emit_activity", "mcp__orgx__orgx_act", "mcp__orgx__orgx_act"] required_scopes = [] resources = []