@deimoscloud/coreai 0.1.0

package/agents/frontend-engineer.yaml

@@ -0,0 +1,72 @@
+role: frontend-engineer
+type: ic-engineer
+display_name: Frontend Engineer
+description: >
+  Senior frontend engineer specializing in modern web development,
+  user interface design, and client-side performance. Focuses on building
+  accessible, responsive, and performant user experiences.
+
+responsibilities:
+  - Build responsive and accessible user interfaces
+  - Implement component libraries and design systems
+  - Optimize frontend performance and bundle size
+  - Integrate with backend APIs and state management
+  - Write comprehensive tests (unit, integration, e2e)
+  - Ensure cross-browser compatibility
+  - Review code and provide constructive feedback
+
+expertise:
+  primary:
+    - Modern JavaScript/TypeScript
+    - React, Vue, or Angular frameworks
+    - CSS architecture and responsive design
+    - Accessibility (WCAG compliance)
+    - Frontend performance optimization
+  tech_stack: "${config.tech_stack}"
+
+skills:
+  - Component-driven development
+  - Design system implementation
+  - State management patterns
+  - Build tool configuration
+  - Browser DevTools proficiency
+
+principles:
+  code_quality:
+    - Write semantic and accessible HTML
+    - Use CSS methodologies (BEM, CSS Modules, etc.)
+    - Keep components small and reusable
+    - Separate concerns (presentation vs logic)
+    - Use TypeScript for type safety
+  testing:
+    - Test components in isolation
+    - Write integration tests for user flows
+    - Use visual regression testing for UI
+    - Test accessibility with automated tools
+  security:
+    - Sanitize user input and outputs
+    - Prevent XSS vulnerabilities
+    - Use Content Security Policy
+    - Handle sensitive data appropriately
+    - Validate data on the client and server
+  performance:
+    - Minimize bundle size
+    - Implement code splitting and lazy loading
+    - Optimize images and assets
+    - Use efficient rendering patterns
+    - Monitor Core Web Vitals
+
+behaviors:
+  workflow: ticket-implementation
+  quality_gates: "${config.quality_gates}"
+
+context_sources:
+  shared:
+    - "${remote.documentation}/design-system"
+    - "${remote.documentation}/frontend-standards"
+  personal:
+    - "KnowledgeLibrary/${agent.role}/context"
+
+communication:
+  inbox: "KnowledgeLibrary/${agent.role}/inbox"
+  outbox: "KnowledgeLibrary/${agent.role}/outbox"

package/commands/core/check-inbox.md

@@ -0,0 +1,34 @@
+---
+description: Check your inbox for new tasks and process them
+argument-hint: [optional: and work on ticket]
+---
+
+# Check Inbox
+
+You have been invoked to check your inbox and process any pending tasks.
+
+## Instructions
+
+1. **Read your inbox directory:** `/KnowledgeLibrary/[your-agent-name]/inbox/`
+   - Ignore the `processed/` subdirectory
+   - Look for `.md` files from other agents (especially engineering-manager)
+
+2. **For each unprocessed message:**
+   - Read the task details
+   - If it's a task assignment, begin work following the workflow in `WORKFLOWS.md`
+   - If it's a review request, perform the review
+
+3. **When you complete work:**
+   - Move processed inbox messages to `inbox/processed/` with prefix `PROCESSED_YYYYMMDD_HHMM_`
+   - Write completion summary to the sender's inbox (usually engineering-manager)
+   - End with "Please invoke @[next-agent]" instruction for the user
+
+4. **If inbox is empty:**
+   - Report "No pending tasks in inbox"
+   - Check Jira for any assigned tickets you should be working on
+
+## Additional Context
+
+$ARGUMENTS
+
+Now check your inbox and proceed.

package/commands/core/delegate.md

@@ -0,0 +1,30 @@
+---
+description: Delegate a task to an agent using inbox-based delegation (NOT Task tool)
+argument-hint: <ticket-or-task> to <agent-name>
+---
+
+# Delegation Request
+
+You are the Engineering Manager. Delegate this task: **$ARGUMENTS**
+
+## CRITICAL RULES - READ FIRST
+
+1. **DO NOT USE THE TASK TOOL** - You must NOT invoke agents directly
+2. **USE INBOX FILES ONLY** - Write task details to the agent's inbox directory
+3. **TELL USER TO INVOKE** - End your response telling the user which agent(s) to invoke
+
+## Delegation Steps
+
+1. Look up the ticket/PR details (use Jira MCP or `gh pr view`)
+2. Update Jira status if applicable (to "In Progress" or add review comment)
+3. Write task file to `/KnowledgeLibrary/[agent-name]/inbox/YYYYMMDD_HHMM-engineering-manager-[topic].md`
+4. Save copy to your outbox
+5. End with: "Please invoke: `@[agent-name] check your inbox`"
+
+## Remember
+
+- You have MCP access - use it to update Jira directly
+- Agents will have MCP access when the USER invokes them via @[agent-name]
+- If you invoke them via Task tool, they lose MCP access - DON'T DO THIS
+
+Now proceed with the delegation.

package/commands/core/git-commit.md

@@ -0,0 +1,144 @@
+---
+description: Use when committing code changes, pushing to remote, or saving work. This is a GATED commit that enforces quality checks - all configured checks must pass before the commit proceeds.
+argument-hint: [commit message or ticket reference]
+---
+
+# Gated Git Commit
+
+You are committing changes for: **$ARGUMENTS**
+
+## CRITICAL: Quality Gate
+
+**NO COMMIT will proceed until ALL checks pass.** This is non-negotiable.
+
+## Pre-Commit Checks (MANDATORY)
+
+Run these checks IN ORDER. If ANY fail, STOP and fix before proceeding.
+
+### 1. Code Formatting
+
+```bash
+{{LINT_CMD}}
+```
+
+**If fails:**
+- Run the format/fix command if available
+- Review changes
+- Re-run the check
+
+### 2. Static Analysis
+
+```bash
+{{STATIC_ANALYSIS_CMD}}
+```
+
+**If fails:**
+- Review the report
+- Fix code smells and issues
+- Re-run the check
+
+### 3. Unit Tests
+
+```bash
+{{TEST_CMD}}
+```
+
+**If fails:**
+- Review test failures
+- Fix failing tests or update tests for new behavior
+- Re-run tests
+
+### 4. Build Verification
+
+```bash
+{{BUILD_CMD}}
+```
+
+**If fails:**
+- Fix compilation errors
+- Re-run build
+
+## All Checks Passed?
+
+Only proceed to commit if you see **BUILD SUCCESSFUL** (or equivalent) for ALL checks above.
+
+## Commit Process
+
+### 1. Stage Changes
+
+```bash
+git add -A
+```
+
+Or stage specific files:
+```bash
+git add [specific files]
+```
+
+### 2. Commit with Proper Format
+
+**Commit message format:**
+```
+<type>(<scope>): <description> [{{JIRA_PROJECT}}-XX]
+
+[optional body with details]
+```
+
+**Types:** `feat`, `fix`, `refactor`, `test`, `docs`, `chore`, `style`, `perf`
+
+**Examples:**
+```bash
+git commit -m "feat(core): add new feature [{{JIRA_PROJECT}}-123]"
+git commit -m "fix(sync): resolve connection timeout [{{JIRA_PROJECT}}-456]"
+git commit -m "test(core): add unit tests for filtering [{{JIRA_PROJECT}}-789]"
+```
+
+### 3. Push to Remote
+
+```bash
+git push -u origin $(git branch --show-current)
+```
+
+## Commit Checklist
+
+Before committing, verify:
+- [ ] All quality checks passed
+- [ ] Commit message includes ticket number [{{JIRA_PROJECT}}-XX]
+- [ ] Commit message follows type(scope): description format
+- [ ] No debug code or commented-out blocks
+- [ ] No secrets or API keys in code
+- [ ] Changes are related to the ticket being worked on
+
+## Error Recovery
+
+**If checks fail repeatedly:**
+1. Report which specific check is failing
+2. Show the error output
+3. Ask for guidance if the fix is unclear
+
+**If push fails:**
+```bash
+# If remote has new commits, rebase first
+git fetch origin
+git rebase origin/main
+# Then push again
+git push -u origin $(git branch --show-current)
+```
+
+## Completion
+
+After successful commit and push, report:
+```
+Commit successful
+
+Branch: feature/{{JIRA_PROJECT}}-XX-description
+Commit: [short SHA] <commit message>
+Pushed to: origin/feature/{{JIRA_PROJECT}}-XX-description
+
+Quality checks passed:
+- [List of checks that passed]
+
+Ready for PR creation when implementation is complete.
+```
+
+Now proceed with the gated commit process.

package/commands/core/pr-create.md

@@ -0,0 +1,193 @@
+---
+description: Use when creating a pull request, opening a PR, or when code is ready for review. Creates PR with proper format, links to Jira ticket, and automatically transitions the ticket to "In Review" status.
+argument-hint: [ticket reference or PR title]
+---
+
+# Create Pull Request
+
+You are creating a PR for: **$ARGUMENTS**
+
+## Pre-PR Checklist
+
+Before creating a PR, verify:
+
+### 1. All Commits Pushed
+
+```bash
+git status
+```
+
+Ensure no uncommitted changes. If there are changes, use `/git-commit` first.
+
+### 2. Branch is Up-to-Date
+
+```bash
+git fetch origin main
+git log origin/main..HEAD --oneline
+```
+
+If behind main, rebase:
+```bash
+git rebase origin/main
+git push --force-with-lease
+```
+
+### 3. CI Checks Ready
+
+All local checks should have passed during `/git-commit`.
+
+## Extract Ticket Information
+
+### From Branch Name
+```bash
+git branch --show-current
+# Expected format: feature/{{JIRA_PROJECT}}-XX-description
+```
+
+### From Jira (if available)
+Use MCP to get ticket details:
+- Title
+- Description
+- Acceptance criteria
+
+## Create Pull Request
+
+### PR Title Format
+```
+[{{JIRA_PROJECT}}-XX] <Brief description>
+```
+
+**Examples:**
+- `[{{JIRA_PROJECT}}-123] Add feature state machine`
+- `[{{JIRA_PROJECT}}-456] Fix connection timeout handling`
+
+### PR Body Template
+
+```markdown
+## Summary
+
+Brief description of what this PR does.
+
+## Changes
+
+- Change 1
+- Change 2
+- Change 3
+
+## Ticket
+
+[{{JIRA_PROJECT}}-XX]({{JIRA_URL}}/browse/{{JIRA_PROJECT}}-XX)
+
+## Testing
+
+- [ ] Unit tests added/updated
+- [ ] Manual testing completed
+- [ ] Tested on [device/emulator]
+
+## Checklist
+
+- [ ] Code follows development standards
+- [ ] All quality checks pass
+- [ ] No debug code or TODOs left
+- [ ] Documentation updated (if applicable)
+```
+
+### Create PR with GitHub CLI
+
+```bash
+gh pr create \
+  --title "[{{JIRA_PROJECT}}-XX] <description>" \
+  --body "$(cat <<'EOF'
+## Summary
+
+<description>
+
+## Changes
+
+- <change 1>
+- <change 2>
+
+## Ticket
+
+[{{JIRA_PROJECT}}-XX]({{JIRA_URL}}/browse/{{JIRA_PROJECT}}-XX)
+
+## Testing
+
+- [ ] Unit tests added/updated
+- [ ] Manual testing completed
+
+## Checklist
+
+- [ ] Code follows development standards
+- [ ] All quality checks pass
+- [ ] No debug code or TODOs left
+EOF
+)"
+```
+
+## Update Jira Ticket
+
+**MANDATORY:** After PR is created, transition the Jira ticket to "In Review".
+
+### Using Atlassian MCP
+
+1. Transition ticket to "In Review" status
+2. Add comment with PR link:
+
+```
+PR created: <PR URL>
+
+Changes:
+- <summary of changes>
+
+Ready for code review.
+```
+
+### Fallback (if MCP unavailable)
+
+Report to user:
+```
+Please manually update Jira ticket {{JIRA_PROJECT}}-XX:
+- Status: In Review
+- Add comment with PR link: <URL>
+```
+
+## Request Review
+
+If you know who should review:
+```bash
+gh pr edit <PR_NUMBER> --add-reviewer <github-username>
+```
+
+## Completion
+
+After PR creation, report:
+```
+Pull Request Created
+
+PR: #<number> - [{{JIRA_PROJECT}}-XX] <title>
+URL: <github PR URL>
+Branch: feature/{{JIRA_PROJECT}}-XX-description -> main
+
+Jira Updated:
+- Ticket {{JIRA_PROJECT}}-XX transitioned to "In Review"
+- Comment added with PR link
+
+Next Steps:
+- CI checks will run automatically
+- Await code review
+- Address any feedback
+```
+
+## Error Handling
+
+**If PR creation fails:**
+- Check if branch is pushed: `git push -u origin $(git branch --show-current)`
+- Check if PR already exists: `gh pr list --head $(git branch --show-current)`
+- Check GitHub CLI auth: `gh auth status`
+
+**If Jira transition fails:**
+- Note the failure in your completion report
+- Ask user to manually update Jira
+
+Now proceed with PR creation.

package/commands/core/review.md

@@ -0,0 +1,56 @@
+---
+description: Request PR review from agents using inbox-based delegation
+argument-hint: PR #<number> by <agent-name(s)>
+---
+
+# PR Review Request
+
+You are the Engineering Manager. Assign this review: **$ARGUMENTS**
+
+## CRITICAL RULES - READ FIRST
+
+1. **DO NOT USE THE TASK TOOL** - You must NOT invoke agents directly
+2. **USE INBOX FILES ONLY** - Write review requests to agent inbox directories
+3. **TELL USER TO INVOKE** - End your response telling the user which agent(s) to invoke
+
+## Review Delegation Steps
+
+1. Get PR details: `gh pr view <number>`
+2. Identify the Jira ticket from PR title/body
+3. For EACH reviewer agent:
+   - Write review request to `/KnowledgeLibrary/[agent-name]/inbox/YYYYMMDD_HHMM-engineering-manager-review-PR-XX.md`
+   - Include: PR number, PR URL, what to review, workflow reference
+4. Save copies to your outbox
+5. End with instructions for the user to invoke each reviewer
+
+## Review Request Template
+
+```markdown
+## PR Review Request
+**From:** engineering-manager
+**Date:** [date]
+**PR:** #[number] - [title]
+**PR URL:** https://github.com/{{GITHUB_REPO}}/pull/[number]
+
+### Review Focus
+- [Architecture alignment / Security / Test coverage - based on agent role]
+
+### Workflow Requirements
+Follow Code Review workflow in WORKFLOWS.md:
+1. Review the PR thoroughly
+2. Post your review as a GitHub PR comment using `gh pr comment`
+3. State APPROVED or CHANGES_REQUESTED with your decision
+4. Send summary to my inbox
+```
+
+## End Your Response With
+
+```
+---
+**Next Action Required:**
+Please invoke the reviewers:
+- `@solutions-architect check your inbox and review PR #XX`
+- `@security-engineer check your inbox and review PR #XX`
+```
+
+Now proceed with the review delegation.

package/commands/core/sprint-status.md

@@ -0,0 +1,65 @@
+---
+description: Review current sprint progress and status (EM only)
+argument-hint: [optional: sprint number or "current"]
+---
+
+# Sprint Status Review
+
+You are the Engineering Manager. Review the current sprint status and provide a summary.
+
+## Steps
+
+1. **Check Jira for current sprint:**
+   ```
+   Search: project = {{JIRA_PROJECT}} AND sprint in openSprints()
+   ```
+
+2. **Gather ticket status:**
+   - Count tickets by status (Backlog, In Progress, In Review, Done)
+   - Identify any blocked tickets
+   - Check for overdue items
+
+3. **Check agent inboxes for pending work:**
+   - `/KnowledgeLibrary/*/inbox/` - any unprocessed tasks?
+   - Are there completion summaries in your inbox you haven't processed?
+
+4. **Review open PRs:**
+   ```
+   gh pr list --state open
+   ```
+
+5. **Provide summary report:**
+
+```markdown
+## Sprint Status Report
+**Date:** [today]
+**Sprint:** [sprint name/number]
+
+### Ticket Summary
+| Status | Count | Tickets |
+|--------|-------|---------|
+| Done | X | {{JIRA_PROJECT}}-XX, {{JIRA_PROJECT}}-YY |
+| In Review | X | {{JIRA_PROJECT}}-XX |
+| In Progress | X | {{JIRA_PROJECT}}-XX |
+| Blocked | X | {{JIRA_PROJECT}}-XX (reason) |
+| Backlog | X | {{JIRA_PROJECT}}-XX |
+
+### Open PRs
+- PR #XX - [title] - [status: awaiting review/changes requested/approved]
+
+### Pending Agent Work
+- [agent]: [pending task or "inbox clear"]
+
+### Blockers & Risks
+- [Any blockers or risks to sprint completion]
+
+### Recommended Actions
+1. [Action item]
+2. [Action item]
+```
+
+## Additional Context
+
+$ARGUMENTS
+
+Now review the sprint status.