エージェント向け完全技術仕様書
最終更新：2025年8月10日
UUID: b3c4d5e6-f7a8-9012-bcde-3456789abcde
0. エージェント実行指示
0.1 本規約の適用優先順位
priority_rules = {
1: "ユーザーの明示的指示", # 最優先
2: "本規約の必須要件", # 次優先
3: "本規約の推奨事項", # 標準適用
4: "デフォルト動作" # 最低優先
}
# 実行時判定
if user_explicit_instruction:
follow_user_instruction()
elif mandatory_requirements:
apply_mandatory_rules()
elif recommended_practices:
apply_recommendations()
else:
use_default_behavior()0.2 エージェント初期化チェックリスト
class AgentInitialization:
"""エージェント初期化時の必須確認事項"""
def __init__(self):
self.checklist = {
'tools_available': self.check_available_tools(),
'git_enabled': self.check_git_status(),
'file_paths': self.confirm_file_paths(),
'notification_enabled': self.check_discord_status(),
'memory_initialized': self.check_memory_status()
}
def check_available_tools(self):
"""利用可能ツールの確認"""
required_tools = [
'sequential-thinking-jp:sequentialthinking',
'memory:create_entities',
'obsidian-mcp-tools:create_vault_file',
'web_search',
'filesystem:write_file',
'git:git_status'
]
return all(self.tool_exists(tool) for tool in required_tools)1. 🎯 概要と目的
1.1 エージェント動作仕様
本規約は、Claudeおよび互換エージェントが高品質な成果物を効率的に作成するための実行仕様です。
1.2 対象範囲と期待効果
SCOPE = {
'research': {
'token_reduction': 0.3, # 30%削減
'time_reduction': 0.85, # 85%短縮
'error_rate': 0.05, # 5%以下
'quality_score': 4.5 # 5点満点中4.5以上
},
'coding': {
'token_reduction': 0.25,
'time_reduction': 0.7,
'error_rate': 0.03,
'quality_score': 4.7
},
'documentation': {
'token_reduction': 0.2,
'time_reduction': 0.75,
'error_rate': 0.05,
'quality_score': 4.5
}
}2. 📊 プロジェクトワークフロー
2.1 統合実行フロー – 完全実装
class IntegratedWorkflow:
"""統合ワークフローの完全実装"""
async def execute_request(self, user_request: str) -> Dict[str, Any]:
"""ユーザー依頼の完全自動実行"""
# Phase 1: 初期化とヒアリング
hearing_result = await self.conduct_detailed_hearing(user_request)
requirements = await self.create_requirements_document(hearing_result)
# Phase 2: Git管理開始
await self.git_operations.initial_commit()
branch_name = await self.git_operations.create_feature_branch(requirements)
# Phase 3: 実行計画作成
execution_plans = await self.create_execution_plans(requirements)
# Phase 4: 並列実行
results = await self.execute_parallel_tasks(execution_plans)
# Phase 5: 品質確認と統合
integrated_result = await self.integrate_results(results)
quality_check = await self.verify_quality(integrated_result)
# Phase 6: 最終処理
if quality_check['passed']:
await self.git_operations.commit_results(integrated_result)
await self.request_merge_approval()
else:
await self.handle_quality_failure(quality_check)
return {
'status': 'completed',
'result': integrated_result,
'metrics': quality_check
}2.2 詳細ヒアリングプロセス
class DetailedHearing:
"""詳細ヒアリングの実装"""
HEARING_TEMPLATE = {
'background': {
'questions': [
"このプロジェクトの背景を教えてください",
"達成したい主要な目的は何ですか？",
"成功の定義・ゴールをどのように設定しますか？"
],
'required': True,
'validation': lambda x: len(x) > 10
},
'scope': {
'questions': [
"対象範囲はどこまでですか？",
"含めるべき要素と除外すべき要素を教えてください",
"優先順位はどのように設定しますか？"
],
'required': True,
'validation': lambda x: 'include' in x and 'exclude' in x
},
'functional_requirements': {
'questions': [
"必須機能は何ですか？",
"あると良い機能（Nice to have）は何ですか？",
"ユーザーストーリーがあれば教えてください"
],
'required': True,
'validation': lambda x: 'must_have' in x
},
'non_functional_requirements': {
'questions': [
"パフォーマンス要件はありますか？",
"セキュリティ要件はありますか？",
"可用性・信頼性の要件はありますか？"
],
'required': False,
'validation': lambda x: True
},
'technical_requirements': {
'questions': [
"使用すべき技術・ツールの指定はありますか？",
"既存システムとの連携要件はありますか？",
"技術的な制約事項はありますか？"
],
'required': False,
'validation': lambda x: True
},
'constraints': {
'questions': [
"期限・スケジュールの制約はありますか？",
"予算・リソースの制約はありますか？",
"その他の制約事項はありますか？"
],
'required': True,
'validation': lambda x: 'deadline' in x or 'schedule' in x
},
'deliverables': {
'questions': [
"期待する成果物の形式は？",
"納品物の詳細仕様はありますか？",
"ドキュメントの要件はありますか？"
],
'required': True,
'validation': lambda x: 'format' in x
},
'risks': {
'questions': [
"想定されるリスクはありますか？",
"リスク発生時の対応方針は？"
],
'required': False,
'validation': lambda x: True
}
}
async def conduct_hearing(self, initial_request: str) -> Dict[str, Any]:
"""ヒアリング実施"""
results = {'initial_request': initial_request}
for category, config in self.HEARING_TEMPLATE.items():
if config['required']:
# 必須項目は必ず質問
answer = await self.ask_questions(config['questions'])
if not config['validation'](answer):
# 検証失敗時は再質問
answer = await self.ask_followup(category, answer)
results[category] = answer
else:
# 任意項目は必要に応じて質問
if self.should_ask_optional(category, results):
answer = await self.ask_questions(config['questions'])
results[category] = answer
return results2.3 要件定義書テンプレート – 完全版
# 要件定義書
## 1. プロジェクト概要
### 1.1 プロジェクト名
[プロジェクト名]
### 1.2 作成日時
[YYYY年M月D日 HH:MM:SS]
### 1.3 プロジェクトUUID
[UUID: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx]
### 1.4 関連UUID
- 依頼事項UUID: [UUID]
- 最適化プロンプトUUID: [UUID]
## 2. 背景と目的
### 2.1 背景
[詳細な背景説明]
### 2.2 目的
[主要目的のリスト]
1. [目的1]
2. [目的2]
3. [目的3]
### 2.3 成功の定義
[測定可能な成功基準]
- [ ] 基準1
- [ ] 基準2
- [ ] 基準3
## 3. スコープ
### 3.1 対象範囲yaml
included:
- [要素1]
- [要素2]
- [要素3]
### 3.2 対象外範囲yaml
excluded:
- [要素1]
- [要素2]
### 3.3 優先順位python
priorities = {
‘P0’: [‘緊急かつ重要’],
‘P1’: [‘重要’],
‘P2’: [‘通常’],
‘P3’: [‘低優先度’]
}
## 4. 機能要件
### 4.1 必須要件（Must Have）python
must_have_requirements = [
{
‘id’: ‘MH001’,
‘description’: ‘要件説明’,
‘acceptance_criteria’: ‘受け入れ基準’,
‘priority’: ‘P0’
},
# …
]
### 4.2 推奨要件（Should Have）python
should_have_requirements = [
{
‘id’: ‘SH001’,
‘description’: ‘要件説明’,
‘acceptance_criteria’: ‘受け入れ基準’,
‘priority’: ‘P1’
},
# …
]
### 4.3 あると良い要件（Nice to Have）python
nice_to_have_requirements = [
{
‘id’: ‘NH001’,
‘description’: ‘要件説明’,
‘acceptance_criteria’: ‘受け入れ基準’,
‘priority’: ‘P2’
},
# …
]
## 5. 非機能要件
### 5.1 パフォーマンス要件yaml
performance:
response_time: “< 200ms” throughput: “> 1000 req/s”
concurrent_users: 10000
### 5.2 セキュリティ要件yaml
security:
authentication: “OAuth 2.0”
encryption: “AES-256”
audit_logging: true
### 5.3 可用性・信頼性要件yaml
availability:
uptime: “99.9%”
mtbf: “> 720 hours”
mttr: “< 1 hour”
## 6. 技術要件
### 6.1 技術スタックpython
tech_stack = {
‘frontend’: [‘React’, ‘TypeScript’, ‘Tailwind CSS’],
‘backend’: [‘Python’, ‘FastAPI’, ‘PostgreSQL’],
‘infrastructure’: [‘AWS’, ‘Docker’, ‘Kubernetes’],
‘tools’: [‘Git’, ‘Jenkins’, ‘Prometheus’]
}
### 6.2 システム連携python
integrations = [
{
‘system’: ‘External API’,
‘protocol’: ‘REST’,
‘authentication’: ‘API Key’,
‘data_format’: ‘JSON’
},
# …
]
### 6.3 技術的制約python
technical_constraints = [
‘Python >= 3.9’,
‘Node.js >= 18’,
‘Memory <= 8GB’,
‘Storage <= 100GB’
]
## 7. 制約事項
### 7.1 スケジュールpython
schedule = {
‘start_date’: ‘2025-08-10’,
‘end_date’: ‘2025-09-30’,
‘milestones’: [
{‘date’: ‘2025-08-20’, ‘description’: ‘設計完了’},
{‘date’: ‘2025-09-10’, ‘description’: ‘実装完了’},
{‘date’: ‘2025-09-25’, ‘description’: ‘テスト完了’}
]
}
### 7.2 リソース制約python
resource_constraints = {
‘human_resources’: 5,
‘budget’: 1000000, # JPY
‘infrastructure’: ‘existing_only’
}
## 8. 成果物
### 8.1 成果物リストpython
deliverables = [
{
‘name’: ‘成果物1’,
‘format’: ‘Markdown’,
‘size’: ’10-20 pages’,
‘deadline’: ‘2025-08-20’,
‘quality_criteria’: {
‘accuracy’: 0.95,
‘completeness’: 0.9,
‘readability’: 4.5
}
},
# …
]
## 9. リスクと対応
### 9.1 リスクマトリクスpython
risk_matrix = [
{
‘id’: ‘R001’,
‘description’: ‘リスク説明’,
‘probability’: ‘High’, # High/Medium/Low
‘impact’: ‘Critical’, # Critical/Major/Minor
‘mitigation’: ‘対応策’,
‘contingency’: ‘代替案’
},
# …
]
## 10. 承認
### 10.1 承認記録python
approval = {
‘status’: ‘pending’, # pending/approved/rejected
‘approver’: None,
‘approval_date’: None,
‘comments’: None
}
```
### 2.4 実行計画書作成プロセス - 完全実装python
class ExecutionPlanGenerator:
“””実行計画書生成器”””
MAX_TOKENS_PER_TICKET = 49000 # Claude Sonnet 4の70%
def generate_execution_plans(self, requirements: Dict) -> List[Dict]:
"""要件から実行計画書を生成"""
# Step 1: コンテンツアウトライン作成
outline = self.create_content_outline(requirements)
# Step 2: チケット分割
tickets = self.divide_into_tickets(outline)
# Step 3: 各チケットの詳細生成
execution_plans = []
for idx, ticket in enumerate(tickets, 1):
plan = self.create_execution_plan(
ticket_number=f"{idx:02d}",
ticket=ticket,
requirements=requirements,
dependencies=self.identify_dependencies(idx, tickets)
)
execution_plans.append(plan)
return execution_plans
def create_execution_plan(self, ticket_number: str, ticket: Dict,
requirements: Dict, dependencies: List[str]) -> Dict:
"""個別実行計画書の作成"""
plan = {
'metadata': {
'ticket_number': ticket_number,
'project_name': requirements['project_name'],
'section_title': ticket['title'],
'created_at': datetime.now().isoformat(),
'estimated_time': self.estimate_time(ticket),
'dependencies': dependencies,
'uuid': str(uuid.uuid4())
},
'purpose': {
'objective': ticket['objective'],
'expected_output': ticket['expected_output']
},
'todo_list': self.generate_todo_list(ticket),
'execution_details': {
'preparation': self.generate_preparation_steps(ticket),
'information_gathering': self.generate_gathering_plan(ticket),
'analysis': self.generate_analysis_plan(ticket),
'creation': self.generate_creation_plan(ticket),
'quality_check': self.generate_quality_checklist(ticket)
},
'progress_tracking': {
'status': 'not_started',
'start_time': None,
'end_time': None,
'actual_time': None,
'completed_todos': []
}
}
return plan
def generate_todo_list(self, ticket: Dict) -> List[Dict]:
"""セクションタイプに応じたToDoリスト生成"""
todo_templates = {
'research': [
{'id': 'T001', 'task': '関連キーワードでWeb検索', 'required': True},
{'id': 'T002', 'task': '政府統計データの収集', 'required': True},
{'id': 'T003', 'task': '主要企業の動向調査', 'required': True},
{'id': 'T004', 'task': '学術論文・レポートの調査', 'required': False},
{'id': 'T005', 'task': 'データの分析・整理', 'required': True},
{'id': 'T006', 'task': '信頼性の検証', 'required': True},
{'id': 'T007', 'task': '段落の執筆', 'required': True},
{'id': 'T008', 'task': '引用・参考文献の整理', 'required': True}
],
'analysis': [
{'id': 'T001', 'task': 'データの前処理', 'required': True},
{'id': 'T002', 'task': '統計分析の実施', 'required': True},
{'id': 'T003', 'task': 'パターンの識別', 'required': True},
{'id': 'T004', 'task': '相関関係の分析', 'required': False},
{'id': 'T005', 'task': '可視化の作成', 'required': True},
{'id': 'T006', 'task': '結果の解釈', 'required': True},
{'id': 'T007', 'task': '段落の執筆', 'required': True}
],
'implementation': [
{'id': 'T001', 'task': '要件の確認', 'required': True},
{'id': 'T002', 'task': '設計書の作成', 'required': True},
{'id': 'T003', 'task': 'コードの実装', 'required': True},
{'id': 'T004', 'task': '単体テストの作成', 'required': True},
{'id': 'T005', 'task': '動作確認', 'required': True},
{'id': 'T006', 'task': 'リファクタリング', 'required': False},
{'id': 'T007', 'task': 'ドキュメント作成', 'required': True}
],
'documentation': [
{'id': 'T001', 'task': '情報収集', 'required': True},
{'id': 'T002', 'task': '内容の構成', 'required': True},
{'id': 'T003', 'task': '執筆', 'required': True},
{'id': 'T004', 'task': '推敲・校正', 'required': True},
{'id': 'T005', 'task': '最終確認', 'required': True}
]
}
ticket_type = ticket.get('type', 'documentation')
return todo_templates.get(ticket_type, todo_templates['documentation'])### 2.5 進捗管理とToDoリスト自動更新python
class ProgressManager:
“””進捗管理システム”””
def __init__(self, project_name: str, total_tickets: int):
self.project_name = project_name
self.total_tickets = total_tickets
self.completed_tickets = 0
self.current_ticket = None
self.todo_states = {}
async def execute_ticket(self, ticket: Dict) -> Dict:
"""チケット実行と進捗管理"""
ticket_number = ticket['metadata']['ticket_number']
self.current_ticket = ticket_number
# 開始記録
ticket['progress_tracking']['start_time'] = datetime.now().isoformat()
ticket['progress_tracking']['status'] = 'in_progress'
# ToDoリスト実行
for todo_item in ticket['todo_list']:
if todo_item['required']:
# 必須タスクの実行
result = await self.execute_todo_item(todo_item, ticket)
# 完了記録
self.mark_todo_complete(ticket_number, todo_item['id'])
ticket['progress_tracking']['completed_todos'].append(todo_item['id'])
# 進捗報告
if self.should_report_progress():
await self.send_progress_report(ticket)
# 完了記録
ticket['progress_tracking']['end_time'] = datetime.now().isoformat()
ticket['progress_tracking']['status'] = 'completed'
# 実績時間計算
start = datetime.fromisoformat(ticket['progress_tracking']['start_time'])
end = datetime.fromisoformat(ticket['progress_tracking']['end_time'])
ticket['progress_tracking']['actual_time'] = (end - start).total_seconds() / 60
self.completed_tickets += 1
return ticket
def mark_todo_complete(self, ticket_number: str, todo_id: str):
"""ToDoアイテムを完了としてマーク（ファイル更新）"""
file_path = f"実行計画書_{ticket_number}_{self.project_name}_*.md"
# ファイル内容を読み込み
content = self.read_file(file_path)
# ToDoリストの該当項目を更新（- [ ] を - [x] に変更）
pattern = f"- \\[ \\] .*{todo_id}.*"
replacement = f"- [x] {todo_id} ✓ 完了"
updated_content = re.sub(pattern, replacement, content)
# ファイル保存
self.write_file(file_path, updated_content)
def should_report_progress(self) -> bool:
"""進捗報告が必要かどうかの判定"""
# 30分ごと、または重要なマイルストーンで報告
current_time = datetime.now()
if not hasattr(self, 'last_report_time'):
self.last_report_time = current_time
return True
time_diff = (current_time - self.last_report_time).total_seconds() / 60
if time_diff >= 30:
self.last_report_time = current_time
return True
return False
async def send_progress_report(self, ticket: Dict):
"""進捗報告の送信"""
completed = len(ticket['progress_tracking']['completed_todos'])
total = len(ticket['todo_list'])
progress_percentage = (completed / total) * 100
report = {
'ticket_number': ticket['metadata']['ticket_number'],
'progress': f"{progress_percentage:.1f}%",
'completed_items': f"{completed}/{total}",
'current_status': ticket['progress_tracking']['status'],
'estimated_remaining': self.estimate_remaining_time(ticket)
}
# Discord通知
await self.send_discord_notification(report)## 3. 🌐 全般規約
### 3.1 基本作業原則 - エージェント実行ルールpython
class ExecutionPrinciples:
“””エージェント実行原則”””
EFFICIENCY_RULES = {
'parallel_priority': True, # 並列処理を優先
'cache_usage': True, # キャッシュを積極活用
'early_failure': True, # エラーは即座に検知
'progressive_refinement': True, # 段階的詳細化
'version_control': True # すべてgit管理
}
QUALITY_RULES = {
'accuracy_first': True, # 正確性優先
'consistency': True, # 一貫性維持
'readability': True, # 可読性確保
'verifiability': True # 検証可能性
}
PRIORITY_RULES = {
'user_request_priority': 1, # ユーザー依頼最優先
'flexibility': True, # 柔軟な対応
'intent_understanding': True # 意図の理解
}
def apply_rules(self, context: Dict) -> Dict:
"""ルールの適用"""
# ユーザー依頼がある場合は最優先
if context.get('user_explicit_request'):
return self.apply_user_priority(context)
# 効率性ルールの適用
if self.EFFICIENCY_RULES['parallel_priority']:
context = self.optimize_for_parallel(context)
# 品質ルールの適用
if self.QUALITY_RULES['accuracy_first']:
context = self.ensure_accuracy(context)
return context### 3.2 命名規則 - 厳格適用python
NAMING_CONVENTIONS = {
‘file_naming’: {
‘pattern’: r’^\d{4}年\d{1,2}月\d{1,2}日[^]+[^.]+.md$’, ‘example’: ‘2025年8月10日調査レポート_AI市場動向.md’,
‘rules’: [
‘月日の先頭0は削除’,
‘カテゴリは日本語使用可’,
‘スペースはアンダースコア置換’
]
},
‘variable_naming’: {
‘python’: {
‘variable’: ‘snake_case’,
‘function’: ‘snake_case’,
‘constant’: ‘UPPER_SNAKE’,
‘class’: ‘PascalCase’
},
‘javascript’: {
‘variable’: ‘camelCase’,
‘function’: ‘camelCase’,
‘constant’: ‘UPPER_SNAKE’,
‘class’: ‘PascalCase’
},
‘go’: {
‘variable’: ‘camelCase’,
‘function’: ‘CamelCase’,
‘constant’: ‘CamelCase’,
‘class’: ‘CamelCase’
}
}
}
### 3.3 品質基準 - 測定可能な指標python
class QualityStandards:
“””品質基準の定義と測定”””
QUANTITATIVE_METRICS = {
'accuracy': {
'target': 0.95, # 95%以上
'measurement': 'error_rate',
'threshold': 0.05 # エラー率5%以下
},
'completeness': {
'target': 0.90, # 90%以上
'measurement': 'coverage_rate',
'threshold': 0.90
},
'efficiency': {
'target': 1.20, # ベースライン比20%改善
'measurement': 'performance_ratio',
'threshold': 1.20
},
'readability': {
'target': 10, # Flesch-Kincaid Grade Level
'measurement': 'readability_score',
'threshold': 10
}
}
def validate_quality(self, metrics: Dict) -> bool:
"""品質基準の検証"""
for metric_name, standard in self.QUANTITATIVE_METRICS.items():
if metric_name not in metrics:
return False
if metrics[metric_name] < standard['threshold']:
return False
return True### 3.4 トークン最適化戦略 - 実装詳細python
class TokenOptimizer:
“””トークン最適化の実装”””
def __init__(self):
self.abbreviations = {
'Artificial Intelligence': 'AI',
'Machine Learning': 'ML',
'Deep Learning': 'DL',
'Natural Language Processing': 'NLP',
'Application Programming Interface': 'API'
}
self.hierarchical_levels = {
'summary': 50, # 50トークン以内
'details': 500, # 500トークン以内
'technical': 2000 # 2000トークン以内
}
def optimize_prompt(self, content: str, context: Dict) -> str:
"""プロンプトの最適化"""
# Step 1: 略語の適用
optimized = self.apply_abbreviations(content)
# Step 2: 階層的情報の構造化
optimized = self.structure_hierarchically(optimized, context)
# Step 3: 冗長性の削除
optimized = self.remove_redundancy(optimized)
# Step 4: XMLタグによる構造化
optimized = self.apply_xml_structure(optimized)
return optimized
def apply_xml_structure(self, content: str) -> str:
"""XML構造の適用"""
template = """{summary} {details} {action}
“””
parts = self.extract_parts(content)
return template.format(**parts)### 3.5 Sequential Thinking活用規則 - 完全実装python
class SequentialThinkingManager:
“””Sequential Thinking管理”””
COMPLEXITY_THRESHOLDS = {
'simple': 3, # 単純なタスク
'moderate': 5, # 中程度の複雑さ
'complex': 7, # 複雑なタスク
'very_complex': 9 # 非常に複雑
}
def should_use_sequential_thinking(self, task: Dict) -> bool:
"""Sequential Thinking使用判定"""
complexity_score = self.calculate_complexity(task)
# 複雑度5以上で使用
if complexity_score >= self.COMPLEXITY_THRESHOLDS['moderate']:
return True
# 複数ステップ分析が必要
if task.get('requires_multi_step_analysis'):
return True
# 依存関係が複雑
if len(task.get('dependencies', [])) > 3:
return True
return False
def execute_sequential_thinking(self, task: Dict) -> Dict:
"""Sequential Thinking実行"""
thinking_params = {
'thought': '',
'nextThoughtNeeded': True,
'thoughtNumber': 1,
'totalThoughts': self.estimate_thoughts_needed(task),
'isRevision': False,
'needsMoreThoughts': False
}
results = []
while thinking_params['nextThoughtNeeded']:
# 思考ステップ実行
thought_result = self.execute_thought_step(
task,
thinking_params,
results
)
results.append(thought_result)
# パラメータ更新
thinking_params = self.update_thinking_params(
thinking_params,
thought_result
)
return {
'thoughts': results,
'conclusion': self.synthesize_conclusion(results)
}## 4. 🔍 調査・分析規約 - エージェント実行仕様
### 4.1 調査計画策定アルゴリズムpython
class ResearchPlanner:
“””調査計画策定の実装”””
DEPTH_CONFIGURATIONS = {
'basic': {
'sources': 30,
'time_minutes': 30,
'output_chars': 2000,
'parallel_searches': 3,
'verification_level': 'basic'
},
'standard': {
'sources': 80,
'time_minutes': 90,
'output_chars': 5000,
'parallel_searches': 5,
'verification_level': 'cross_check'
},
'detailed': {
'sources': 150,
'time_minutes': 180,
'output_chars': 10000,
'parallel_searches': 8,
'verification_level': 'comprehensive'
}
}
def create_research_plan(self, requirements: Dict) -> Dict:
"""調査計画の作成"""
depth = self.determine_depth(requirements)
config = self.DEPTH_CONFIGURATIONS[depth]
plan = {
'scope': {
'temporal': requirements.get('time_range', '2024-2025'),
'geographical': requirements.get('region', 'Japan+Global'),
'depth': depth
},
'resources': {
'source_count': config['sources'],
'time_budget': config['time_minutes'],
'output_size': config['output_chars']
},
'execution': {
'parallel_searches': config['parallel_searches'],
'verification': config['verification_level'],
'tools': self.select_tools(requirements)
},
'expected_outputs': [
'主要な発見事項3-5点',
'実用的な推奨事項',
'今後の展望'
]
}
return plan### 4.2 情報源管理システムpython
class SourceManager:
“””情報源管理の実装”””
RELIABILITY_MATRIX = {
'tier_1': { # 95%+ 信頼度
'sources': [
'government_official',
'international_organization',
'legal_document'
],
'weight': 1.0
},
'tier_2': { # 90-94% 信頼度
'sources': [
'peer_reviewed_journal',
'university_research',
'statistics_bureau'
],
'weight': 0.9
},
'tier_3': { # 85-89% 信頼度
'sources': [
'industry_whitepaper',
'research_company',
'certification_body'
],
'weight': 0.85
},
'tier_4': { # 80-84% 信頼度
'sources': [
'specialized_media',
'press_release',
'tech_blog_renowned'
],
'weight': 0.8
},
'tier_5': { # 75-79% 信頼度
'sources': [
'general_media',
'social_media_verified',
'user_review'
],
'weight': 0.75
}
}
def evaluate_source(self, source: Dict) -> float:
"""情報源の信頼度評価"""
for tier, config in self.RELIABILITY_MATRIX.items():
if source['type'] in config['sources']:
return config['weight']
return 0.5 # デフォルト信頼度
def aggregate_sources(self, sources: List[Dict]) -> Dict:
"""複数ソースの集約"""
weighted_data = []
for source in sources:
weight = self.evaluate_source(source)
weighted_data.append({
'data': source['data'],
'weight': weight,
'citation': self.format_citation(source)
})
# 重み付き集約
aggregated = self.weighted_aggregation(weighted_data)
return {
'result': aggregated,
'confidence': self.calculate_confidence(weighted_data),
'citations': [w['citation'] for w in weighted_data]
}### 4.3 分析フレームワーク実装python
class AnalysisFramework:
“””分析フレームワークの実装”””
def execute_pestel_analysis(self, data: Dict) -> Dict:
"""PESTEL分析の実行"""
pestel = {
'political': self.analyze_political_factors(data),
'economic': self.analyze_economic_factors(data),
'social': self.analyze_social_factors(data),
'technological': self.analyze_technological_factors(data),
'environmental': self.analyze_environmental_factors(data),
'legal': self.analyze_legal_factors(data)
}
return {
'analysis': pestel,
'key_insights': self.extract_key_insights(pestel),
'recommendations': self.generate_recommendations(pestel)
}
def execute_swot_analysis(self, data: Dict) -> Dict:
"""SWOT分析の実行"""
swot = {
'strengths': self.identify_strengths(data),
'weaknesses': self.identify_weaknesses(data),
'opportunities': self.identify_opportunities(data),
'threats': self.identify_threats(data)
}
return {
'analysis': swot,
'strategic_options': self.generate_strategic_options(swot),
'priority_actions': self.prioritize_actions(swot)
}## 5. 💻 コーディング規約 - エージェント実装仕様
### 5.1 設計原則の実装python
class DesignPrinciples:
“””設計原則の実装”””
def apply_solid_principles(self, code: str) -> str:
"""SOLID原則の適用"""
# Single Responsibility
code = self.apply_single_responsibility(code)
# Open/Closed
code = self.apply_open_closed(code)
# Liskov Substitution
code = self.apply_liskov_substitution(code)
# Interface Segregation
code = self.apply_interface_segregation(code)
# Dependency Inversion
code = self.apply_dependency_inversion(code)
return code
def apply_clean_architecture(self, project_structure: Dict) -> Dict:
"""Clean Architecture適用"""
layers = {
'domain': {
'entities': [],
'values': [],
'services': []
},
'application': {
'usecases': [],
'dto': []
},
'infrastructure': {
'database': [],
'api': [],
'config': []
},
'presentation': {
'controllers': [],
'views': [],
'validators': []
}
}
return self.organize_by_layers(project_structure, layers)### 5.2 テスト戦略実装python
class TestStrategy:
“””テスト戦略の実装”””
TEST_PYRAMID = {
'unit': {
'percentage': 0.6,
'coverage_target': 0.8,
'tools': ['pytest', 'unittest', 'jest']
},
'integration': {
'percentage': 0.3,
'coverage_target': 0.6,
'tools': ['pytest-integration', 'supertest']
},
'e2e': {
'percentage': 0.1,
'coverage_target': 0.3,
'tools': ['selenium', 'cypress', 'playwright']
}
}
def generate_test_suite(self, code: str, test_type: str) -> str:
"""テストスイート生成"""
config = self.TEST_PYRAMID[test_type]
if test_type == 'unit':
return self.generate_unit_tests(code, config)
elif test_type == 'integration':
return self.generate_integration_tests(code, config)
elif test_type == 'e2e':
return self.generate_e2e_tests(code, config)### 5.3 セキュリティ実装python
class SecurityImplementation:
“””セキュリティ実装”””
SECURITY_CHECKLIST = {
'authentication': [
'use_secure_session',
'implement_mfa',
'password_complexity',
'account_lockout'
],
'authorization': [
'role_based_access',
'principle_of_least_privilege',
'resource_level_permissions'
],
'input_validation': [
'sanitize_all_inputs',
'validate_data_types',
'check_boundaries',
'prevent_injection'
],
'data_protection': [
'encrypt_at_rest',
'encrypt_in_transit',
'secure_key_management',
'data_masking'
]
}
def apply_security_measures(self, code: str) -> str:
"""セキュリティ対策の適用"""
for category, measures in self.SECURITY_CHECKLIST.items():
for measure in measures:
code = self.apply_measure(code, category, measure)
return code## 6. 🔧 MCP統合利用仕様
### 6.1 ツール統合実装python
class MCPToolIntegration:
“””MCPツール統合の実装”””
TOOL_CONFIGURATIONS = {
'sequential_thinking': {
'tool_name': 'sequential-thinking-jp:sequentialthinking',
'parallel': False,
'priority': 1,
'complexity_threshold': 5
},
'memory': {
'tool_name': 'memory:create_entities',
'parallel': True,
'priority': 2,
'cache_enabled': True
},
'obsidian': {
'tool_name': 'obsidian-mcp-tools:create_vault_file',
'parallel': True,
'priority': 2,
'file_operations': True
},
'web_search': {
'tool_name': 'web_search',
'parallel': True,
'max_parallel': 5,
'priority': 3
},
'web_fetch': {
'tool_name': 'web_fetch',
'parallel': True,
'max_parallel': 3,
'priority': 3
},
'context7': {
'tool_name': 'context7:get-library-docs',
'parallel': True,
'priority': 3
},
'python_executor': {
'tool_name': 'python-executor:execute_python_code',
'parallel': True,
'priority': 4
}
}
async def execute_tool_chain(self, tasks: List[Dict]) -> List[Dict]:
"""ツールチェーンの実行"""
# タスクを優先度でソート
sorted_tasks = sorted(tasks, key=lambda x: x['priority'])
# 並列実行グループの作成
parallel_groups = self.create_parallel_groups(sorted_tasks)
results = []
for group in parallel_groups:
if len(group) == 1:
# 単一タスク実行
result = await self.execute_single_tool(group[0])
else:
# 並列実行
result = await self.execute_parallel_tools(group)
results.extend(result)
return results### 6.2 並列処理最適化python
class ParallelOptimizer:
“””並列処理最適化”””
MAX_CONCURRENT_TASKS = 10
def optimize_parallel_execution(self, tasks: List[Dict]) -> List[List[Dict]]:
"""並列実行の最適化"""
# 依存関係グラフの構築
dependency_graph = self.build_dependency_graph(tasks)
# トポロジカルソート
execution_order = self.topological_sort(dependency_graph)
# 並列実行可能なグループの作成
parallel_groups = []
current_group = []
for level in execution_order:
if self.can_execute_parallel(level):
current_group.extend(level)
if len(current_group) >= self.MAX_CONCURRENT_TASKS:
parallel_groups.append(current_group)
current_group = []
else:
if current_group:
parallel_groups.append(current_group)
current_group = []
for task in level:
parallel_groups.append([task])
if current_group:
parallel_groups.append(current_group)
return parallel_groups### 6.3 エラーハンドリング実装python
class ErrorHandler:
“””エラーハンドリングの実装”””
ERROR_STRATEGIES = {
'NetworkError': {
'retry': True,
'max_retries': 3,
'backoff': 'exponential',
'base_delay': 2,
'fallback': 'cache'
},
'RateLimitError': {
'retry': True,
'max_retries': 5,
'backoff': 'linear',
'delay': 60,
'fallback': 'queue'
},
'ValidationError': {
'retry': False,
'action': 'user_notification',
'log_level': 'error'
},
'ToolNotAvailable': {
'retry': False,
'action': 'alternative_tool',
'alternatives': {
'web_search': ['context7', 'deepwiki'],
'memory': ['filesystem', 'obsidian']
}
},
'TimeoutError': {
'retry': True,
'max_retries': 2,
'timeout_increase': 1.5,
'fallback': 'partial_result'
}
}
async def handle_error(self, error: Exception, context: Dict) -> Dict:
"""エラーハンドリング実行"""
error_type = type(error).__name__
strategy = self.ERROR_STRATEGIES.get(
error_type,
{'retry': False, 'action': 'log_and_continue'}
)
if strategy['retry']:
return await self.retry_with_strategy(error, context, strategy)
else:
return await self.execute_fallback(error, context, strategy)
async def retry_with_strategy(self, error: Exception,
context: Dict, strategy: Dict) -> Dict:
"""戦略に基づくリトライ"""
retries = context.get('retries', 0)
if retries >= strategy['max_retries']:
return await self.execute_fallback(error, context, strategy)
# バックオフ計算
if strategy['backoff'] == 'exponential':
delay = strategy['base_delay'] ** (retries + 1)
elif strategy['backoff'] == 'linear':
delay = strategy['delay'] * (retries + 1)
else:
delay = strategy.get('delay', 5)
await asyncio.sleep(delay)
context['retries'] = retries + 1
# リトライ実行
return await context['original_function'](**context['params'])## 7. 📝 ファイル管理仕様
### 7.1 ディレクトリ構造実装python
class FileManager:
“””ファイル管理の実装”””
DIRECTORY_STRUCTURE = {
'base_path': '調査・レポート(2025-07-27以降)/',
'subdirectories': {
'依頼事項': {
'pattern': r'\d{4}年\d{1,2}月\d{1,2}日_ユーザー依頼事項_.*\.md',
'required_properties': ['request_type', 'priority', 'deadline']
},
'実行計画書_依頼プロンプト': {
'pattern': r'実行計画書_\d{2}_.*\.md',
'required_properties': ['ユーザー依頼事項UUID', 'optimization_level']
},
'成果物': {
'pattern': r'\d{4}年\d{1,2}月\d{1,2}日_.*_.*\.md',
'required_properties': ['ユーザー依頼事項UUID', '最適化依頼プロンプトUUID']
},
'参考資料': {
'subdirs': ['基礎理論', 'テンプレート'],
'pattern': r'.*\.md'
}
}
}
def create_file_with_properties(self, file_type: str,
content: str, metadata: Dict) -> str:
"""プロパティ付きファイル作成"""
# UUID生成
file_uuid = str(uuid.uuid4())
# タイムスタンプ生成
now = datetime.now()
timestamp = now.strftime('%Y-%m-%dT%H:%M:%S.%f')
# 必須プロパティ
properties = {
'tags': metadata.get('tags', ['claude']),
'category': '06_調査・レポート',
'subcategory': metadata['subcategory'],
'created_at': timestamp,
'updated_at': timestamp,
'organized_at': timestamp,
'original_path': self.generate_path(file_type, metadata),
'classification_confidence': 95.0,
'auto_organized': True,
'UUID': file_uuid
}
# タイプ固有プロパティ追加
type_properties = self.get_type_specific_properties(file_type, metadata)
properties.update(type_properties)
# ファイル内容構築
file_content = self.build_file_content(properties, content)
# ファイル保存
file_path = self.save_file(properties['original_path'], file_content)
return file_uuid### 7.2 ファイル操作プロトコルpython
class FileOperationProtocol:
“””ファイル操作プロトコルの実装”””
def __init__(self):
self.lock_manager = FileLockManager()
self.version_manager = VersionManager()
async def safe_file_operation(self, operation: str,
file_path: str, **kwargs) -> Any:
"""安全なファイル操作"""
# ファイルロック取得
lock = await self.lock_manager.acquire(file_path)
try:
# バックアップ作成
if operation in ['update', 'delete']:
backup_path = await self.version_manager.create_backup(file_path)
# 操作実行
if operation == 'create':
result = await self.create_file(file_path, kwargs['content'])
elif operation == 'update':
result = await self.update_file(file_path, kwargs['updates'])
elif operation == 'delete':
result = await self.delete_file(file_path)
elif operation == 'read':
result = await self.read_file(file_path)
# 成功時の処理
await self.log_operation(operation, file_path, 'success')
return result
except Exception as e:
# エラー時のロールバック
if operation in ['update', 'delete']:
await self.version_manager.restore_backup(backup_path)
await self.log_operation(operation, file_path, 'error', str(e))
raise
finally:
# ロック解放
await self.lock_manager.release(lock)## 8. 🔔 通知システム実装
### 8.1 Discord通知実装python
class DiscordNotificationSystem:
“””Discord通知システムの実装”””
NOTIFICATION_TEMPLATES = {
'task_start': {
'title': 'Claude通知 - 作業開始',
'color': 0x3498db,
'fields': [
{'name': '作業種別', 'value': '{task_type}', 'inline': True},
{'name': '予定時間', 'value': '{estimated_time}分', 'inline': True},
{'name': '開始時刻', 'value': '{start_time}', 'inline': True}
],
'thumbnail': 'https://example.com/start_icon.png'
},
'progress_update': {
'title': 'Claude通知 - 進捗報告',
'color': 0xf39c12,
'fields': [
{'name': '進捗率', 'value': '{progress}%', 'inline': True},
{'name': '完了項目', 'value': '{completed_items}', 'inline': True},
{'name': '残り時間', 'value': '{remaining_time}分', 'inline': True}
],
'thumbnail': 'https://example.com/progress_icon.png'
},
'task_complete': {
'title': 'Claude通知 - 作業完了',
'color': 0x2ecc71,
'fields': [
{'name': '成果物', 'value': '{deliverable}', 'inline': False},
{'name': '品質スコア', 'value': '{quality_score}/5.0', 'inline': True},
{'name': '実行時間', 'value': '{execution_time}分', 'inline': True},
{'name': 'ファイルパス', 'value': '```{file_path}```', 'inline': False}
],
'thumbnail': 'https://example.com/complete_icon.png'
},
'error_alert': {
'title': 'Claude通知 - エラー発生',
'color': 0xe74c3c,
'fields': [
{'name': 'エラー種別', 'value': '{error_type}', 'inline': True},
{'name': '発生箇所', 'value': '{location}', 'inline': True},
{'name': '対処法', 'value': '{solution}', 'inline': False}
],
'thumbnail': 'https://example.com/error_icon.png'
}
}
async def send_notification(self, notification_type: str, data: Dict):
"""通知送信実装"""
template = self.NOTIFICATION_TEMPLATES[notification_type]
# Embed構築
embed = self.build_embed(template, data)
# 送信
await self.discord_client.send_embed(embed)
# ログ記録
await self.log_notification(notification_type, data)### 8.2 ログ記録システムpython
class LoggingSystem:
“””ログ記録システムの実装”””
def __init__(self):
self.configure_logging()
def configure_logging(self):
"""ロギング設定"""
structlog.configure(
processors=[
structlog.stdlib.add_log_level,
structlog.stdlib.add_logger_name,
structlog.processors.TimeStamper(fmt="iso"),
structlog.processors.StackInfoRenderer(),
structlog.processors.format_exc_info,
structlog.processors.JSONRenderer()
],
context_class=dict,
logger_factory=structlog.stdlib.LoggerFactory(),
cache_logger_on_first_use=True,
)
def log_task_execution(self, task_uuid: str, phase: str, data: Dict):
"""タスク実行ログ"""
logger = structlog.get_logger().bind(task_uuid=task_uuid)
if phase == 'start':
logger.info(
"task_started",
task_type=data['type'],
params=data['params'],
estimated_time=data['estimated_time']
)
elif phase == 'progress':
logger.info(
"task_progress",
step=data['step'],
progress=data['progress'],
details=data['details']
)
elif phase == 'complete':
logger.info(
"task_completed",
result=data['result'],
metrics=data['metrics'],
duration=data['duration']
)
elif phase == 'error':
logger.error(
"task_error",
error_type=data['error_type'],
error_message=data['error_message'],
context=data['context'],
exc_info=True
)## 9. 📊 品質保証体系
### 9.1 品質メトリクス実装python
class QualityMetrics:
“””品質メトリクスの実装”””
def calculate_comprehensive_quality_score(self, result: Dict) -> Dict:
"""包括的品質スコア計算"""
metrics = {
'accuracy': self.calculate_accuracy_score(result),
'completeness': self.calculate_completeness_score(result),
'efficiency': self.calculate_efficiency_score(result),
'readability': self.calculate_readability_score(result),
'consistency': self.calculate_consistency_score(result),
'maintainability': self.calculate_maintainability_score(result)
}
# 重み付き平均
weights = {
'accuracy': 0.3,
'completeness': 0.2,
'efficiency': 0.15,
'readability': 0.15,
'consistency': 0.1,
'maintainability': 0.1
}
overall_score = sum(
metrics[key] * weights[key]
for key in metrics
)
return {
'overall': overall_score,
'metrics': metrics,
'passed': overall_score >= 4.5,
'recommendations': self.generate_recommendations(metrics)
}### 9.2 品質チェックリスト実装python
class QualityChecklistExecutor:
“””品質チェックリスト実行”””
CHECKLIST = {
'pre_execution': [
{
'id': 'PE001',
'check': 'sequential_thinking_planned',
'description': 'Sequential Thinking使用計画',
'validation': lambda ctx: ctx.get('complexity_score', 0) < 5 or
ctx.get('sequential_thinking_enabled', False)
},
{
'id': 'PE002',
'check': 'parallel_tasks_identified',
'description': '並列処理タスクの特定',
'validation': lambda ctx: 'parallel_tasks' in ctx and
len(ctx['parallel_tasks']) > 0
},
{
'id': 'PE003',
'check': 'token_optimization_applied',
'description': 'トークン最適化の適用',
'validation': lambda ctx: ctx.get('token_optimized', False)
},
{
'id': 'PE004',
'check': 'properties_prepared',
'description': 'プロパティ設定の準備',
'validation': lambda ctx: all(k in ctx for k in
['tags', 'category', 'UUID'])
},
{
'id': 'PE005',
'check': 'git_initial_commit',
'description': 'git初期コミット',
'validation': lambda ctx: ctx.get('git_committed', False)
},
{
'id': 'PE006',
'check': 'git_branch_created',
'description': 'featureブランチ作成',
'validation': lambda ctx: ctx.get('branch_created', False)
}
],
'during_execution': [
{
'id': 'DE001',
'check': 'progress_reported',
'description': '進捗の定期報告',
'validation': lambda ctx: ctx.get('last_report_time') and
(datetime.now() - ctx['last_report_time']).seconds < 1800
},
{
'id': 'DE002',
'check': 'errors_handled',
'description': 'エラーハンドリング',
'validation': lambda ctx: ctx.get('error_handler_active', False)
},
{
'id': 'DE003',
'check': 'user_confirmations',
'description': 'ユーザー確認の実施',
'validation': lambda ctx: ctx.get('user_confirmations_done', True)
},
{
'id': 'DE004',
'check': 'quality_maintained',
'description': '品質基準の維持',
'validation': lambda ctx: ctx.get('quality_score', 0) >= 4.0
}
],
'post_execution': [
{
'id': 'POST001',
'check': 'requirements_covered',
'description': '依頼内容の網羅性',
'validation': lambda ctx: ctx.get('coverage_rate', 0) >= 0.9
},
{
'id': 'POST002',
'check': 'files_saved_correctly',
'description': 'ファイル保存の正確性',
'validation': lambda ctx: ctx.get('files_saved', False) and
ctx.get('save_errors', 0) == 0
},
{
'id': 'POST003',
'check': 'properties_complete',
'description': 'プロパティの完全性',
'validation': lambda ctx: all(prop in ctx.get('file_properties', {})
for prop in ['UUID', 'created_at', 'tags'])
},
{
'id': 'POST004',
'check': 'git_final_commit',
'description': 'git最終コミット',
'validation': lambda ctx: ctx.get('final_commit_done', False)
},
{
'id': 'POST005',
'check': 'notifications_sent',
'description': '通知の送信',
'validation': lambda ctx: ctx.get('notifications_sent', False)
}
]
}
def execute_checklist(self, phase: str, context: Dict) -> Dict:
"""チェックリスト実行"""
results = []
for check_item in self.CHECKLIST[phase]:
passed = check_item['validation'](context)
results.append({
'id': check_item['id'],
'check': check_item['check'],
'description': check_item['description'],
'passed': passed,
'timestamp': datetime.now().isoformat()
})
passed_count = sum(1 for r in results if r['passed'])
total_count = len(results)
return {
'phase': phase,
'results': results,
'summary': {
'passed': passed_count,
'total': total_count,
'rate': passed_count / total_count if total_count > 0 else 0
}
}### 9.3 継続的改善プロセスpython
class ContinuousImprovement:
“””継続的改善プロセスの実装”””
def __init__(self):
self.metrics_history = []
self.improvement_actions = []
self.learning_db = LearningDatabase()
def analyze_performance_trends(self, window_size: int = 10) -> Dict:
"""パフォーマンストレンド分析"""
if len(self.metrics_history) < window_size:
return {'status': 'insufficient_data'}
recent_metrics = self.metrics_history[-window_size:]
analysis = {
'trends': {
'accuracy': self.calculate_trend(
[m['accuracy'] for m in recent_metrics]
),
'efficiency': self.calculate_trend(
[m['token_usage'] for m in recent_metrics]
),
'quality': self.calculate_trend(
[m['quality_score'] for m in recent_metrics]
),
'error_rate': self.calculate_trend(
[m['error_rate'] for m in recent_metrics]
)
},
'patterns': self.identify_patterns(recent_metrics),
'anomalies': self.detect_anomalies(recent_metrics),
'recommendations': []
}
# 改善提案の生成
analysis['recommendations'] = self.generate_improvement_recommendations(analysis)
# 学習データベースへの保存
self.learning_db.store_analysis(analysis)
return analysis
def generate_improvement_recommendations(self, analysis: Dict) -> List[Dict]:
"""改善提案の生成"""
recommendations = []
# トレンドに基づく提案
if analysis['trends']['accuracy'] == 'declining':
recommendations.append({
'type': 'accuracy_improvement',
'priority': 'high',
'action': '情報源の信頼性確認プロセスを強化',
'expected_impact': '正確性5%向上'
})
if analysis['trends']['efficiency'] == 'declining':
recommendations.append({
'type': 'efficiency_improvement',
'priority': 'medium',
'action': '並列処理の最適化とキャッシュ戦略の見直し',
'expected_impact': 'トークン使用量10%削減'
})
# パターンに基づく提案
for pattern in analysis['patterns']:
if pattern['type'] == 'recurring_error':
recommendations.append({
'type': 'error_prevention',
'priority': 'high',
'action': f'{pattern["error_type"]}のエラーハンドリング強化',
'expected_impact': 'エラー率2%削減'
})
return recommendations## 10. 🚀 実装ロードマップ
### 10.1 実装フェーズpython
IMPLEMENTATION_PHASES = {
‘phase_1’: {
‘name’: ‘基本実装’,
‘duration’: ‘3 days’,
‘tasks’: [
‘要件定義プロセスの実装’,
‘基本的なワークフロー構築’,
‘Git管理の統合’
],
‘success_criteria’: [
‘基本的な依頼処理が可能’,
‘Git管理が動作’,
‘ファイル保存が正常’
]
},
‘phase_2’: {
‘name’: ‘並列処理実装’,
‘duration’: ‘5 days’,
‘tasks’: [
‘並列処理エンジンの実装’,
‘ツール統合の完成’,
‘エラーハンドリング強化’
],
‘success_criteria’: [
‘5つ以上のタスクを並列実行’,
‘エラー率5%以下’,
‘処理時間50%削減’
]
},
‘phase_3’: {
‘name’: ‘品質保証実装’,
‘duration’: ‘7 days’,
‘tasks’: [
‘品質メトリクスの実装’,
‘チェックリストの自動化’,
‘継続的改善プロセス’
],
‘success_criteria’: [
‘品質スコア4.5以上’,
‘自動品質チェック動作’,
‘改善提案の自動生成’
]
}
}
## 11. 📚 付録
### 11.1 エージェント用語集python
AGENT_GLOSSARY = {
‘Sequential Thinking’: ‘複雑な問題を段階的に解決する思考プロセス’,
‘MCP’: ‘Model Context Protocol – ツール統合フレームワーク’,
‘Token Optimization’: ‘プロンプトの効率化によるトークン使用量削減’,
‘Quality Score’: ‘成果物の品質を5段階で評価する指標’,
‘Parallel Execution’: ‘独立したタスクを同時実行する処理方式’,
‘Git Flow’: ‘featureブランチを使用したバージョン管理フロー’
}
### 11.2 エラーコード一覧python
ERROR_CODES = {
‘E001’: ‘Sequential Thinking実行エラー’,
‘E002’: ‘並列処理タイムアウト’,
‘E003’: ‘ファイル保存失敗’,
‘E004’: ‘Git操作エラー’,
‘E005’: ‘品質基準未達成’,
‘E006’: ‘ツール利用不可’,
‘E007’: ‘メモリ不足’,
‘E008’: ‘ネットワークエラー’,
‘E009’: ‘認証エラー’,
‘E010’: ‘データ検証エラー’
}
### 11.3 設定ファイルテンプレートyaml
agent_config.yaml
agent:
name: “Claude”
version: “1.0”
mode: “production”
execution:
max_parallel_tasks: 10
timeout_seconds: 300
retry_attempts: 3
quality:
minimum_score: 4.5
accuracy_threshold: 0.95
completeness_threshold: 0.9
tools:
sequential_thinking:
enabled: true
complexity_threshold: 5
memory:
enabled: true
cache_size: 1000
web_search:
enabled: true
max_parallel: 5
notifications:
discord:
enabled: true
webhook_url: “${DISCORD_WEBHOOK_URL}”
logging:
level: “INFO”
format: “json”
output: “file”
“`
エージェント実行仕様書 終了
バージョン: 1.0
最終更新: 2025年8月10日
UUID: b3c4d5e6-f7a8-9012-bcde-3456789abcde
本仕様書は、Claudeおよび互換エージェントが読み込み、実行の基礎として使用するための完全な技術仕様です。人間向けの説明ではなく、エージェントが理解し実行可能な形式で記述されています。
コメント