Ensemble Implement

CC Workshop Issue Implementation

Overview

Autonomously discover, claim, implement, and deliver a single agent-ready Issue from the CC Workshop Linear project. This skill covers the full cycle: query Linear for work, write code via TDD across React frontend and Rust backend, verify all checks, and submit a Pull Request.

Project Context

• Frontend: React 18 + TypeScript 5.9 + Tailwind CSS 4 + Zustand 5
• Backend: Tauri 2.9 + Rust (edition 2021)
• Testing: Vitest + @testing-library/react (frontend), cargo test (backend)
• Repo: https://github.com/O0000-code/CC-Workshop.git

Read AGENTS.md for the full project conventions before starting.

Workflow

1) Discover Agent-Ready Issues

CRITICAL RULES:

• You MUST actually call the MCP tools. Do NOT fabricate or hallucinate tool call results.
• If an MCP tool call fails, report the failure honestly. Do NOT pretend it succeeded.
• Use list_teams to find your team ID dynamically. NEVER hardcode team IDs.
• Use list_projects to find the "CC Workshop" project. NEVER hardcode project IDs.
• Use list_issue_labels to find label IDs dynamically. NEVER hardcode label IDs.

Query Linear for issues ready for agent implementation:

1. Use list_teams to get the team ID.
2. Use list_projects to find the "CC Workshop" project ID.
3. Use list_issue_labels to find the IDs for labels: agent-ready and CC Workshop.
4. Use list_issues with filters to find issues that have the agent-ready label AND belong to the CC Workshop project.
5. Sort results by priority (1=Urgent is highest, 4=Low is lowest).
6. Select the single highest-priority issue.

If no agent-ready issues are found: report "No pending agent-ready issues in CC Workshop" and exit immediately. Do NOT proceed further.

2) Read the Issue

• Use get_issue to fetch the full Issue details of the selected issue.
• Read the Description and all comments carefully.
• Use list_comments to read all existing comments on the issue.
• If any requirements are unclear or ambiguous, use create_comment to ask for clarification and stop execution until answered.

3) Claim the Issue

• Use list_issue_statuses to find the status ID for "In Progress". NEVER hardcode status IDs.
• Use list_issue_labels to find the label ID for agent-in-progress. If the label does not exist, create it using create_issue_label.
• Update the Issue via save_issue:
  • stateId: set to the "In Progress" status ID
  • labelIds: add agent-in-progress label while preserving all existing labels
• Post a comment via create_comment:

  **Codex Agent Status: Claimed**
  Implementation plan:
  - {step 1}
  - {step 2}
  - ...
  Affected layers: {Frontend / Backend / Both}
  

4) Create Working Branch

• Use the Issue's gitBranchName if available; otherwise create:

  git checkout -b agent/{type}/{issue-id}
  

  Where {type} is feat, fix, refactor, test, docs, or chore based on the Issue type.

5) Analyze Impact

• Determine which layers are affected (Frontend, Backend, or Both).
• If both layers are affected, ensure type definitions stay in sync:
  • Frontend types: src/types/
  • Backend types: src-tauri/src/types.rs
• Check for downstream dependencies in stores, components, and Tauri commands.
• Review existing tests for the affected areas.

6) Implement Changes (TDD Preferred)

Frontend Changes

1. Write tests first using Vitest + @testing-library/react:
   • Place tests adjacent to source files or in src/test/
   • Mock Tauri IPC calls using vi.mock
   • Use proper RTL queries (getByRole, getByText over getByTestId)
2. Implement the feature/fix:
   • Functional components with hooks only
   • Tailwind CSS 4 utility classes for styling
   • Zustand stores for state management
   • safeInvoke from src/utils/tauri.ts for all Tauri IPC calls
   • Path alias @/ for imports from src/
3. For new pages: add route in App.tsx, sidebar entry if needed.

Backend Changes

1. Write tests first using Rust #[test]:
   • Add #[cfg(test)] module at the bottom of the file
   • Focus on pure functions and data processing logic
   • Skip tests that require full Tauri App context
2. Implement the feature/fix:
   • Use #[tauri::command] for new IPC handlers
   • Register new commands in lib.rs invoke_handler
   • Use Result<T, String> for error handling
   • Use serde for serialization
3. Update types: If command signatures change, update both types.rs and src/types/.

7) Verify

• Run frontend checks:

  npx tsc --noEmit
  npm run test
  

• Run backend checks:

  cd src-tauri && cargo test
  cd src-tauri && cargo clippy -- -D warnings
  

• All must pass before proceeding. If any step fails, fix the issues and re-verify. Do NOT proceed to PR creation with failing builds, tests, or lint errors.

8) Create Pull Request

gh pr create \
  --title "Fixes {issue_identifier}: {short description}" \
  --body "## Summary
{concise description of changes}

## Changes
### Frontend
- {change 1}
- {change 2}

### Backend
- {change 1}
- {change 2}

## Test Results
- TypeScript: no errors
- Frontend tests: {passed}/{total} passed
- Rust tests: {passed}/{total} passed
- Clippy: clean

## Checklist
- [ ] Tests added for new functionality
- [ ] All existing tests pass
- [ ] TypeScript compiles without errors
- [ ] Clippy passes without warnings
- [ ] Frontend/backend types are in sync
- [ ] No protected files modified

Closes {issue_identifier}"

9) Update Linear

• Use list_issue_labels to find the label ID for human-review. If the label does not exist, create it using create_issue_label.
• Update Issue via save_issue:
  • labelIds: add human-review label while preserving all existing labels
• Post a comment via create_comment:

  **Codex Agent Status: Completed**
  PR: {pr_url}
  Layers affected: {Frontend / Backend / Both}
  Changes: {brief summary}
  Test results: Frontend {passed}/{total}, Backend {passed}/{total}
  

CRITICAL RULES

Dynamic Linear Strategy

• NEVER hardcode any Linear IDs (team IDs, project IDs, label IDs, status IDs). Always discover them dynamically using list_teams, list_projects, list_issue_labels, list_issue_statuses.
• If a required label does not exist, create it using create_issue_label before proceeding.
• If the "CC Workshop" project does not exist, create it using save_project with name "CC Workshop" and description "CC Workshop Tauri desktop app - AI-assisted autonomous development workflow".
• ALWAYS include projectId when creating or updating issues.
• After calling save_issue, check the returned result for the issue ID and URL to confirm success.

Implementation Safety

• Stay strictly within the Issue's described scope.
• If you discover additional issues during implementation, create separate Linear Issues for them -- do not fix them in the current branch.
• Never push directly to main.
• Never modify protected files (tauri.conf.json, Cargo.lock, package-lock.json, AGENTS.md).
• When modifying IPC signatures, always update both the Rust handler and the frontend caller.
• Keep commit history clean with conventional commit messages: type(scope): description.
• If uncertain about any decision, post a Linear comment and wait for human guidance.

One Issue Per Session

• Implement exactly one issue per invocation. Do NOT attempt to batch multiple issues.
• After completing the PR, update Linear and exit.