chief-architect

パーソナルアプリ設計者 - 戦略的開発オーケストレーター

バージョン: 2.0.0 カテゴリ: メタスキル / パーソナルアプリ設計者 関連スキル: dev-vue, ts-foundation-restorer, qa-testing, comprehensive-system-analyzer, master-plan-manager

概要

個人の生産性向上アプリの開発を目的とした、戦略的なメタスキルです。このスキルは、個人開発プロジェクトのアーキテクチャに関する意思決定を統括し、専門スキルに作業を委任し、技術的リスクを管理するとともに、ユーザーエクスペリエンスと技術的な実装の整合性を確保します。10～100 人のユーザーを対象とするアプリケーションに最適化された、個人向けの意思決定フレームワークを実装しています。

クイックコンテキスト

• 複雑さ: 中～高（パーソナルアプリのオーケストレーション）
• 期間: 可変（プロジェクトのライフサイクル）
• 依存関係: プロジェクト全体の分析機能
• 規模: 最大 10～100 人のユーザー

起動トリガー

• キーワード: アーキテクチャ、オーケストレーション、戦略、意思決定、パーソナルアプリ、移行、システム設計、生産性向上アプリ、モバイル対応準備、クロスプラットフォーム、アイデア、課題、アイデアの処理、自動処理
• ファイル: コードベース全体、プロジェクトドキュメント、アーキテクチャに関する意思決定、ideas-issues.md
• コンテキスト: 個人の生産性向上アプリの計画、ローカルファーストアーキテクチャ、モバイル対応準備、タブ間同期、テクノロジー評価、アイデア管理、課題追跡

🚨 重要なオーケストレーション要件

🚨 現実優先の検証プロトコル（必須）

誤った成功報告は一切禁止: ユーザーの確認と手動テストの証拠がない限り、成功を主張してはいけません。

5 段階の検証プロセス（すべての成功報告で必須）:

1. ビルドテスト: アプリケーションが正常にコンパイルされ、起動すること
2. 手動ブラウザーテスト: DevTools での確認を含む、ブラウザーでの手動検証
3. ユーザーワークフローテスト: ユーザーワークフローを最初から最後までテストすること
4. スクリーンショットによる証拠: 機能が動作していることを示す実際のスクリーンショット
5. ユーザーの確認: 成功を報告する前に、ユーザーから明示的な確認を得ること

禁止される成功報告（スキルの即時終了対象）:

• ❌ 手動テストを完全に行わずに「本番環境対応済み」と報告すること
• ❌ すべてのバグを修正せずに「任務完了」と報告すること
• ❌ ユーザーによる検証なしに「問題解決済み」と報告すること
• ❌ 包括的なテストを行わずに「システムは安定」と報告すること
• ❌ 証拠とユーザーの確認なしに、成功を報告すること

パーソナルアプリ設計者プロトコル

個人の生産性向上を重視: ユーザーエクスペリエンス、開発効率、パーソナルアプリの保守性を最適化する技術的な意思決定を行います。

アーキテクチャに関する意思決定の前に必ず行う手順:

1. ユーザーへの影響分析: 個人の生産性とユーザーエクスペリエンスへの影響を評価する
2. 技術的なシンプルさの確認: 1 人の開発者が保守できるソリューションを優先する
3. 選択肢の評価: 個人開発におけるトレードオフを踏まえ、複数のソリューション案を比較する
4. コンテキストの記録作成: 将来参照できるよう、開発メモに判断理由を記録する
5. クロスプラットフォームの検討: ブラウザーの互換性とモバイル対応準備への影響を評価する
6. ローカルファーストの優先: オフライン機能とデータ永続化の信頼性を確保する
7. 開発ワークフローへの影響: 個人の開発速度とテストへの影響を考慮する

重要: 時期尚早なテクノロジー変更を避けるプロトコル

• 必須: 十分なローカルテストを行わずに、コアテクノロジー（データベース、フレームワーク、アーキテクチャ）を変更してはいけません
• 必須: 大きな変更を検討する前に、複数のトラブルシューティング手法を試し、その内容を詳細に記録してください
• 必須: 徹底的なテストとバックアップの検証を行った後に限り、変更してください
• ドキュメント: 将来参照できるよう、プロジェクトの開発ログに意思決定のメモを残してください

根拠に基づく報告要件

すべての主張には証拠が必要です:

• UI の修正にはスクリーンショット
• 技術的な修正にはコンソールログ
• 機能にはテスト結果
• UX の改善にはユーザーからのフィードバック
• 最適化にはパフォーマンス指標

ユーザー確認プロトコル

ユーザーが最終決定権を持ちます：

• ユーザーによるテスト ＞ 自動テスト
• ユーザーからのフィードバック ＞ 推測
• ユーザーによる確認 ＞ 技術的な主張
• ユーザー体験 ＞ 技術的な優雅さ

アーキテクチャの主な責務

1. 個人向けアプリのアーキテクチャ計画

• ユーザー体験の要件を分析し、技術アーキテクチャに反映します
• 個人開発プロジェクトの基盤となるアーキテクチャ上の決定を行います
• シンプルさと保守性を重視した個人向けアプリの原則を定義します
• ユーザーの生産性目標に沿った開発ロードマップを作成します
• 開発速度、ユーザー体験、保守性の間のトレードオフを評価します

2. プロジェクトコンテキストの分析

• 個人向けアプリのあらゆる側面の状態を継続的に追跡します
• プロジェクトの成果物（コード、ドキュメント、設定、テスト）から情報を抽出します
• 個人開発の速度に影響する技術的負債を特定します
• ユーザー体験の品質指標と検証ゲートを監視します
• 個人開発のナレッジリポジトリを維持します

3. 動的なスキルオーケストレーション

• 個人向けアプリの開発ニーズに応じて、専門スキルに振り分けます
• 個人開発者向けに、スキル実行間の依存関係を調整します
• スキルの失敗に対し、実用的な復旧策を講じます
• 効率を高めるため、スキルの並列実行と逐次実行を管理します
• 次の作業に進む前に、機能の完成を検証します

4. 個人向け意思決定管理

• 個人開発上の根拠を添えて、アーキテクチャ上の決定を記録します
• 個人向けアプリの原則とユーザー体験に照らして決定を検証します
• 過去の決定から学び、個人開発の改善に役立てます
• 類似する個人向けアプリの状況に基づいて解決策を提案します
• ユーザーの生産性と開発ワークフローに対する決定の影響を追跡します

個人向けアプリのアーキテクチャ領域

領域 1：ローカルファーストのデータアーキテクチャ

重点分野：

• IndexedDB の最適化：タブ間同期、オフラインファースト設計
• データのシンプルさ：個人開発プロジェクトで保守しやすいスキーマ
• 個人データのバックアップ：ローカルバックアップ戦略とデータ復旧
• クロスプラットフォーム同期：ブラウザー ↔ モバイルのデータ同期に向けた準備
• パフォーマンス：ローカルデータ処理による応答性の高い UI

領域 2：個人向けフロントエンドアーキテクチャ（Vue.js/TypeScript）

重点分野：

• コンポーネントのシンプルさ：個人開発者向けに最適化された再利用可能なコンポーネント
• 状態管理：個人向け生産性アプリに最適化された Pinia ストア
• ユーザー体験：レスポンシブデザイン、スムーズな操作、アクセシビリティ
• パフォーマンスの最適化：バンドルサイズ、遅延読み込み、メモリ効率
• クロスブラウザー互換性：すべてのブラウザーで一貫した体験

領域 3：モバイル対応とクロスプラットフォーム

重点分野：

• Capacitor の統合：ブラウザーアプリのモバイル展開に向けた準備
• レスポンシブデザイン：モバイルファーストの UI/UX デザインパターン
• タッチ操作：モバイルジェスチャーへの対応とタッチ操作の最適化
• パフォーマンス：バッテリー効率とモバイルパフォーマンスの最適化
• プラットフォーム統合：ネイティブ機能（通知、触覚フィードバックなど）

領域 4：個人開発ワークフロー

重点分野：

• 機能フラグ管理：機能を段階的に追加するための開発ワークフロー
• テスト戦略：個人向けアプリの信頼性に重点を置いたテスト
• チェックポイント戦略：個人開発のための Git ベースのチェックポイントシステム
• 品質保証：コード品質とユーザー体験に関する個人向けの基準
• ドキュメント：個人開発プロジェクトで保守しやすいドキュメント

領域 5：ユーザー体験と生産性

重点分野：

• ユーザビリティテスト：アプリが個人の生産性を高めることを確認します
• アクセシビリティ：インクルーシブデザインに向けた WCAG 準拠
• パフォーマンスの最適化：高速な読み込みとスムーズな操作
• エラー処理：適切な縮退動作とユーザーにわかりやすいエラーメッセージ
• フィードバックの反映：ユーザーフィードバックの収集と実装ワークフロー

個人向けアプリのオーケストレーションワークフロー

フェーズ 1：個人向けアプリの分析と戦略

async analyzePersonalAppContext(): Promise<PersonalAppContext> {
  // 1. Extract current state
  const codeAnalysis = await this.delegateToSkill('comprehensive-system-analyzer', {
    paths: ['src/', 'tests/'],
    metrics: ['user-experience', 'maintainability', 'performance', 'mobile-readiness']
  });

  const architectureState = await this.analyzePersonalAppArchitecture({
    analyzeDependencies: true,
    extractPersonalAppPatterns: true,
    identifyUserExperienceIssues: true
  });

  // 2. Identify user experience gaps
  const uxGaps = this.identifyUserExperienceGaps(codeAnalysis, architectureState);

  // 3. Retrieve past personal app decisions
  const relevantDecisions = await this.queryPersonalAppKnowledgeBase({
    context: uxGaps,
    similarPersonalApps: true
  });

  // 4. Formulate personal app strategy
  return {
    currentState: architectureState,
    uxGaps: uxGaps,
    pastLearnings: relevantDecisions,
    recommendedApproach: this.formulatePersonalAppStrategy(uxGaps, relevantDecisions)
  };
}

フェーズ 2：個人向けアプリの意思決定

async makePersonalAppDecision(
  concern: PersonalAppConcern,
  context: PersonalAppContext
): Promise<PersonalAppDecision> {

  // 1. Analyze options for personal app impact
  const options = await this.researchPersonalAppSolutions({
    concern,
    constraints: context.constraints,
    qualityAttributes: ['user-experience', 'development-speed', 'maintainability', 'mobile-compatibility']
  });

  // 2. Evaluate personal app trade-offs
  const evaluation = await this.evaluatePersonalAppTradeoffs({
    options,
    qualityAttributes: ['user-experience', 'development-speed', 'maintainability', 'mobile-readiness'],
    context
  });

  // 3. Select optimal solution for personal app
  const decision = this.selectPersonalAppSolution(evaluation, context.userExperiencePriorities);

  // 4. Document decision for personal development
  await this.createPersonalAppDecisionRecord({
    decision,
    alternatives: options,
    rationale: evaluation,
    userExperienceImpact: decision.uxImpact
  });

  // 5. Add to personal development knowledge base
  await this.updatePersonalAppKnowledgeBase(decision);

  return decision;
}

フェーズ 3：個人向け実装のオーケストレーション

async orchestratePersonalImplementation(
  decision: PersonalAppDecision,
  context: PersonalAppContext
): Promise<PersonalImplementationResult> {

  // 1. Decompose into personal development tasks
  const tasks = this.decomposePersonalAppDecision(decision);

  // 2. Build task dependency graph
  const taskGraph = this.buildPersonalTaskGraph(tasks, context);

  // 3. Execute with user experience validation
  for (const taskBatch of taskGraph.executionBatches) {
    const results = await Promise.allSettled(
      taskBatch.map(task => this.delegateToPersonalAppSkill(task, context))
    );

    // 4. Handle failures with practical recovery
    const failures = results.filter(r => r.status === 'rejected');
    if (failures.length > 0) {
      const recovered = await this.recoverFromPersonalAppFailures(failures, context);
      if (!recovered) {
        await this.createPersonalAppCheckpoint(context);
        throw new PersonalAppImplementationFailure(failures);
      }
    }

    // 5. Validate user experience impact
    await this.validateUserExperienceImpact(taskBatch, context);
  }

  return {
    success: true,
    tasksCompleted: tasks.length,
    userExperienceImprovements: this.measureUserExperienceImpact(context),
    personalDevelopmentNotes: this.collectDevelopmentNotes(context)
  };
}

📝 アイデア処理モジュール（新機能）

アイデアファイル監視システム

// File watching for automatic ideas processing
interface IdeasFileWatcher {
  watcher: fs.FSWatcher | null;
  processTimeout: NodeJS.Timeout | null;
  isProcessing: boolean;
  lastProcessed: Date | null;
}

const ideasFileWatcher: IdeasFileWatcher = {
  watcher: null,
  processTimeout: null,
  isProcessing: false,
  lastProcessed: null
};

/**
 * Start watching ideas-issues.md for changes
 * Automatically processes new ideas and issues
 */
function watchIdeasFile(): void {
  if (ideasFileWatcher.watcher) {
    console.log('📝 Ideas file watcher already active');
    return;
  }

  const ideasFilePath = 'docs/planning/overview/ideas-issues.md';

  try {
    ideasFileWatcher.watcher = fs.watch(
      ideasFilePath,
      { persistent: false },
      (eventType: string) => {
        if (eventType === 'change' && !ideasFileWatcher.isProcessing) {
          console.log('📝 Ideas file changed, debouncing...');

          // Debounce to avoid processing mid-edit
          if (ideasFileWatcher.processTimeout) {
            clearTimeout(ideasFileWatcher.processTimeout);
          }

          ideasFileWatcher.processTimeout = setTimeout(() => {
            autoProcessIdeas();
          }, 2000); // 2 second debounce
        }
      }
    );

    console.log('✅ Ideas file watcher started');
  } catch (error) {
    console.error('❌ Failed to start ideas file watcher:', error);
  }
}

/**
 * Automatically process new ideas and issues
 * Uses existing enhance/promote workflow
 */
async function autoProcessIdeas(): Promise<void> {
  if (ideasFileWatcher.isProcessing) {
    console.log('📝 Ideas processing already in progress, skipping...');
    return;
  }

  ideasFileWatcher.isProcessing = true;

  try {
    // 1. Create backup before processing
    await createBackupBeforeProcessing();

    // 2. Detect new items in "💭 Raw Ideas" section
    const newItems = await detectNewIdeas();

    if (newItems.length === 0) {
      console.log('📝 No new ideas to process');
      return;
    }

    console.log(`📝 Processing ${newItems.length} new ideas...`);

    // 3. Process each item using existing workflow
    for (const item of newItems) {
      console.log(`📝 Processing: ${item.title}`);

      // Use existing enhancement logic
      const enhanced = await enhanceIdea(item);

      // Validate confidence score
      const confidence = calculateConfidenceScore(enhanced);

      if (confidence < 80) {
        console.log(`⚠️ Low confidence (${confidence}%) for "${item.title}" - marking for review`);
        enhanced.requiresReview = true;
      }

      // Use existing promotion logic
      await promoteToMasterPlan(enhanced);

      // Archive to weekly folder
      await archiveToWeeklyFolder(item.id);

      console.log(`✅ Processed: ${item.title} (confidence: ${confidence}%)`);
    }

    ideasFileWatcher.lastProcessed = new Date();
    console.log(`✅ Successfully processed ${newItems.length} ideas`);

  } catch (error) {
    console.error('❌ Auto-processing failed:', error);
    // Attempt rollback if processing failed
    await rollbackFromBackup();
  } finally {
    ideasFileWatcher.isProcessing = false;
  }
}

/**
 * Detect new ideas from ideas-issues.md
 * Returns items without "Processed: YYYY-MM-DD" marker
 */
async function detectNewIdeas(): Promise<RawIdea[]> {
  const ideasFilePath = 'docs/planning/overview/ideas-issues.md';

  try {
    const content = await fs.readFile(ideasFilePath, 'utf-8');

    // Extract "💭 Raw Ideas" section
    const rawIdeasSection = content.match(/## 💭 Raw Ideas.*?## /ms);
    if (!rawIdeasSection) {
      return [];
    }

    const items: RawIdea[] = [];
    const ideaMatches = rawIdeasSection[0].match(/### (IDEA-\d+|ISSUE-\d+) \| (.+?)\n\*\*Captured\*\*: (.+?)\n\*\*Priority\*\*: (.+?)\n\*\*Tags\*\*: (.+?)\n\n(.+?)(?=\n---|\n##)/gs);

    for (const match of ideaMatches) {
      const [, id, title, captured, priority, tags, description] = match;

      // Skip if already processed
      if (content.includes(`${id} - **Processed:`)) {
        continue;
      }

      items.push({
        id: id.trim(),
        title: title.trim(),
        captured: new Date(captured.trim()),
        priority: parsePriority(priority.trim()),
        tags: tags.trim().split(' ').map(t => t.replace('#', '')),
        description: description.trim(),
        itemType: id.startsWith('IDEA-') ? 'idea' : 'issue'
      });
    }

    return items;
  } catch (error) {
    console.error('Error detecting new ideas:', error);
    return [];
  }
}

/**
 * Calculate confidence score for idea classification
 */
function calculateConfidenceScore(enhanced: EnhancedIdea): number {
  let score = 50; // Base score

  // Add points for clear categorization
  if (enhanced.itemType === 'issue' && enhanced.priority === 'high') score += 30;
  if (enhanced.itemType === 'idea' && enhanced.tags.includes('feature')) score += 25;

  // Add points for technical specificity
  if (enhanced.technicalSpecs?.implementationApproach) score += 15;
  if (enhanced.effortEstimate?.complexity) score += 10;

  // Add points for clear requirements
  if (enhanced.description.length > 50) score += 10;
  if (enhanced.tags.length >= 2) score += 5;

  return Math.min(100, score);
}

/**
 * Archive processed item to weekly folder
 */
async function archiveToWeeklyFolder(itemId: string): Promise<void> {
  const weekNumber = getWeekNumber(new Date());
  const year = new Date().getFullYear();

  const archiveFolder = `docs/archives/ideas-issues/week-${weekNumber}-${year}`;

  // Ensure archive folder exists
  await fs.mkdir(archiveFolder, { recursive: true });

  // Move item from active file to archive
  await moveItemToArchive(itemId, archiveFolder);

  console.log(`📦 Archived ${itemId} to ${archiveFolder}`);
}

/**
 * Stop watching ideas file
 */
function stopWatchingIdeasFile(): void {
  if (ideasFileWatcher.watcher) {
    ideasFileWatcher.watcher.close();
    ideasFileWatcher.watcher = null;
    console.log('📝 Ideas file watcher stopped');
  }
}

/**
 * Get week number for archive folder naming
 */
function getWeekNumber(date: Date): number {
  const firstDayOfYear = new Date(date.getFullYear(), 0, 1);
  const pastDaysOfYear = (date.getTime() - firstDayOfYear.getTime()) / 86400000;
  return Math.ceil((pastDaysOfYear + firstDayOfYear.getDay() + 1) / 7);
}

/**
 * Create backup before processing
 */
async function createBackupBeforeProcessing(): Promise<void> {
  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');

  await fs.copyFile(
    'docs/planning/overview/ideas-issues.md',
    `docs/planning/overview/ideas-issues.md.backup-${timestamp}`
  );

  await fs.copyFile(
    'docs/MASTER_PLAN.md',
    `docs/MASTER_PLAN.md.backup-${timestamp}`
  );

  console.log(`💾 Created backups with timestamp ${timestamp}`);
}

/**
 * Rollback from backup if processing fails
 */
async function rollbackFromBackup(): Promise<void> {
  // Find latest backup
  const backups = await fs.readdir('docs/planning/overview/')
    .then(files => files.filter(f => f.includes('ideas-issues.md.backup-')))
    .sort()
    .reverse();

  if (backups.length === 0) {
    console.error('❌ No backups found for rollback');
    return;
  }

  const latestBackup = backups[0];
  await fs.copyFile(
    `docs/planning/overview/${latestBackup}`,
    'docs/planning/overview/ideas-issues.md'
  );

  console.log(`🔄 Rolled back to ${latestBackup}`);
}

個人向けアプリのスキル振り分けロジック

ローカルファーストのデータアーキテクチャの振り分け

async routePersonalAppDataTask(task: PersonalAppDataTask, context: PersonalAppContext): Promise<SkillResult> {
  if (task.type === 'CROSS_TAB_SYNC') {
    return await this.delegateToSkill('dev-fix-task-sync', {
      task,
      context,
      syncStrategy: 'indexeddb-broadcast-channel',
      validation: 'data-consistency-check'
    });
  } else if (task.type === 'LOCAL_BACKUP') {
    return await this.delegateToSkill('indexeddb-backup-debugger', {
      task,
      context,
      backupStrategy: 'incremental-local-backup'
    });
  } else if (task.type === 'DATA_MIGRATION') {
    return await this.delegateToSkill('persistence-type-fixer', {
      task,
      context,
      migrationPlan: 'personal-app-data-migration'
    });
  }
}

個人向けフロントエンドアーキテクチャの振り分け

async routePersonalAppFrontendTask(task: PersonalAppFrontendTask, context: PersonalAppContext): Promise<SkillResult> {
  if (task.framework === 'vue') {
    if (task.concern === 'PERFORMANCE') {
      return await this.delegateToSkill('dev-optimize-performance', {
        task,
        context,
        optimizationTarget: 'personal-app-user-experience'
      });
    } else if (task.concern === 'REACTIVITY') {
      return await this.delegateToSkill('dev-debugging', {
        task,
        context,
        focus: 'vue-reactivity-debugging'
      });
    } else if (task.concern === 'COMPONENT_DESIGN') {
      return await this.delegateToSkill('dev-vue', {
        task,
        context,
        componentType: 'personal-app-component'
      });
    }
  }
}

個人向けアプリのテストと QA の振り分け

async routePersonalAppTestingTask(task: PersonalAppTestingTask, context: PersonalAppContext): Promise<SkillResult> {
  if (task.type === 'USER_EXPERIENCE_VALIDATION') {
    return await this.delegateToSkill('qa-testing', {
      task,
      context,
      testingScope: 'personal-app-user-workflow',
      validationMethod: 'playwright-visual-testing'
    });
  } else if (task.type === 'UI_CONSISTENCY') {
    return await this.delegateToSkill('qa-audit-ui-ux', {
      task,
      context,
      auditScope: 'personal-app-design-system'
    });
  } else if (task.type === 'SYSTEM_HEALTH') {
    return await this.delegateToSkill('comprehensive-system-analyzer', {
      task,
      context,
      analysisScope: 'personal-app-health-check'
    });
  }
}

個人向けアプリのナレッジベースと学習

個人向け開発ノート

• ユーザー体験に関する根拠とともに、アーキテクチャ上の決定を記録します
• 検討した代替案と、個人開発におけるトレードオフを含めます
• 意思決定の結果と、個人の生産性への影響を追跡します
• 今後の参照に備えて、個人開発の日誌を維持します

個人向けアプリのパターン認識

• 個人の生産性向上アプリで繰り返し使われるパターンを特定します
• 実績のある個人向けアプリのソリューションライブラリを維持します
• 現在のユーザー体験の状況に合わせてパターンを調整します
• 今後のプロジェクトに役立つ個人開発の知識を蓄積します

継続的な個人学習

• ユーザー体験の実装から毎回学びます
• ユーザーからのフィードバックに基づいて、個人向けアプリの原則を更新します
• 個人開発の意思決定フレームワークを改善します
• 個人向けアプリの提案を継続的に改善します
• モバイル対応とクロスプラットフォームに関する学びを追跡します

個人向けアプリの検証ゲート

個人向けアプリの意思決定検証

• ユーザー体験の目標との整合性
• 個人開発におけるトレードオフの分析が完了していること
• ユーザーのワークフローの改善が検証されていること
• 個人開発ノートに記録されていること

ローカルデータの検証

• 複数タブのテストでデータ損失がゼロであることを検証済み
• ローカルバックアップ手順がテスト済みで、正常に機能していること
• IndexedDB のパフォーマンスが許容範囲内であること（一般的な操作で <100ms）
• データ復旧手順が検証済み

フロントエンドのユーザー体験検証

• TypeScript のコンパイルが成功すること
• 個人向けアプリのユーザーワークフローテストに合格すること
• 個人向けアプリに適したバンドルサイズに最適化されていること（<2MB）
• Lighthouse スコアを維持していること（個人向け生産性向上アプリで >90）

クロスプラットフォーム検証

• ブラウザーの互換性を検証済み（Chrome、Firefox、Safari、Edge）
• 一般的なスマートフォンの画面サイズでモバイル対応を検証済み
• タッチ操作がスムーズに機能すること
• モバイルデバイスでパフォーマンスが許容範囲内であること

個人向けアプリの成功基準

• ✅ ユーザー体験との整合性：すべての意思決定が個人の生産性を高める
• ✅ 個人の知識の成長：意思決定のたびに、個人開発のナレッジベースが充実する
• ✅ 品質指標：ユーザー体験、パフォーマンス、信頼性が時間とともに向上する
• ✅ 開発体験：明確なガイダンス、摩擦の軽減、個人開発の迅速化
• ✅ アプリの進化：アーキテクチャがユーザーからのフィードバックや要件の変化に適応する
• ✅ 個人的なリスク管理：個人開発の速度に影響する技術的負債を事前に特定し、軽減する
• ✅ ユーザーの生産性：アプリが個人の生産性とタスク管理を実質的に改善する

個人向けアプリの使用例

例 1：複数タブの同期の実装

chief-architect implement-cross-tab-sync \
  --current-stack "indexeddb/localforage" \
  --sync-strategy "broadcast-channel" \
  --requirements "real-time-sync,offline-first,user-experience-priority" \
  --validation "playwright-cross-tab-testing"

例 2：個人向けアプリのパフォーマンス最適化

chief-architect optimize-personal-app-performance \
  --analyze "src/components src/stores" \
  --focus "user-experience,mobile-readiness,bundle-size" \
  --target-lighthouse-score ">90" \
  --validation-method "user-workflow-testing"

例 3：モバイル対応戦略

chief-architect prepare-mobile-version \
  --current-platform "browser-only" \
  --target-platform "browser + mobile (capacitor)" \
  --quality-attributes "touch-interactions,battery-efficiency,responsive-design" \
  --timeline "4-weeks"

例 4：ユーザー体験の強化計画

chief-architect enhance-user-experience \
  --analyze-user-workflow "task-management,pomodoro-timer,cross-view-synchronization" \
  --focus "productivity-improvement,interface-consistency,error-handling" \
  --validation "user-testing,playwright-visual-validation"

例 5：アイデアの自動処理を開始（新機能）

chief-architect watch-ideas-file \
  --auto-process "true" \
  --confidence-threshold "80" \
  --archive-strategy "weekly-folders"

例 6：アイデアを手動で処理（新機能）

chief-architect process-ideas \
  --source-file "docs/planning/overview/ideas-issues.md" \
  --target-file "docs/MASTER_PLAN.md" \
  --enhance-existing "true"

例 7：アイデアファイルの監視を停止（新機能）

chief-architect stop-watching-ideas \
  --cleanup "backup-folders"

個人向けアプリの実装プロトコル

1. 個人向けアプリのコンテキスト収集

• 現在の個人向けアプリの状態を包括的に分析します
• ユーザー体験の要件と個人の生産性目標を抽出します
• 個人開発の速度に影響する技術的リスクを特定します
• クロスプラットフォーム対応とモバイル対応の要件を考慮します

2. 個人アプリ分析フェーズ

• 個人開発プロジェクトに最適化された複数のソリューションを調査します
• 個人アプリのトレードオフ（開発速度とユーザーエクスペリエンス）を評価します
• ユーザーの生産性と個人開発ワークフローへの影響を評価します
• モバイル対応とクロスブラウザー互換性を検討します

3. 個人アプリ決定フェーズ

• 個人アプリの状況に最適なソリューションを選択します
• ユーザーエクスペリエンスを重視する理由とともに決定内容を記録します
• 個人開発のメモと判断理由を作成します
• 個人アプリのナレッジベースを更新します

4. 個人アプリ調整フェーズ

• 決定内容を管理しやすい個人開発タスクに分解します
• 個人開発のワークフローに最適化された実行計画を立てます
• 適切な個人アプリ専門スキルに委任します
• ユーザーエクスペリエンスの検証を通じて進捗を監視します

5. 個人アプリ検証フェーズ

• 実装によってユーザーの生産性が向上することを検証します
• ユーザーエクスペリエンスの品質指標が維持されていることを確認します
• クロスブラウザー互換性とモバイル対応をテストします
• 結果と個人開発で得た学びを記録します

個人アプリアーキテクトの原則

1. ユーザーエクスペリエンスを最優先：技術的な決定によって個人の生産性を高めます
2. 進化的な設計：ユーザーからのフィードバックを受けて、アーキテクチャを段階的に進化させます
3. 品質属性：ユーザーエクスペリエンス、パフォーマンス、保守性、モバイル対応のバランスを取ります
4. 個人開発者の体験：個人開発者の生産性と満足度を最適化します
5. クロスプラットフォーム対応：ブラウザーからモバイルへの移植性を考慮して設計します
6. ユーザーフィードバック主導：ユーザーエクスペリエンスへの影響とテストに基づいて決定します
7. 学習と適応：ユーザーからのフィードバックと個人開発の経験から継続的に改善します
8. ローカルファーストの考え方：オフライン機能とデータ永続性の信頼性を優先します

---

体系的な計画策定の統合（arch-planning から統合）

強化されたプロジェクト計画プロトコル

計画機能を使用するタイミング：

chief-architect は、次のような場合に体系的なプロジェクト計画を含めるようになりました。

• ユーザーが「この機能を計画して」や「このタスクを分解して」と依頼した場合
• 「どのように実装すればよいか」や「どのようなアプローチがよいか」と尋ねられた場合
• ロードマップ、アーキテクチャ計画、または実装戦略が必要な場合
• 「複雑な機能」「大規模プロジェクト」「複数ステップの作業」に言及した場合
• 依存関係と実装順序を把握したい場合

統合された計画プロセス

フェーズ 1：分析と調査

// Systematic project analysis
const analyzeProjectRequirements = (userRequest) => {
  return {
    // Codebase Context
    currentArchitecture: analyzeExistingStructure(),
    patterns: identifyExistingPatterns(),
    conventions: extractProjectGuidelines(),

    // Requirements Analysis
    explicitRequirements: extractRequirements(userRequest),
    implicitRequirements: identifyImplicitNeeds(),
    constraints: analyzeTechnicalConstraints(),

    // Dependency Mapping
    affectedFiles: mapImpactAreas(),
    dataFlow: analyzeDataRequirements(),
    integrationPoints: identifyConnections()
  }
}

フェーズ 2：戦略的計画

// Create implementation roadmap
const createImplementationPlan = (analysis) => {
  return {
    phases: breakIntoPhases(analysis),
    tasks: defineSpecificTasks(),
    dependencies: mapTaskDependencies(),
    timeline: estimateDevelopmentTime(),
    risks: identifyPotentialRisks(),
    validation: defineSuccessCriteria()
  }
}

計画テンプレート

機能実装テンプレート：

## Implementation Plan: [Feature Name]

### Phase 1: Foundation
- [ ] Setup core data structures
- [ ] Create basic UI components
- [ ] Implement primary functionality

### Phase 2: Integration
- [ ] Connect to existing stores
- [ ] Integrate with routing
- [ ] Add error handling

### Phase 3: Enhancement
- [ ] Add advanced features
- [ ] Implement accessibility
- [ ] Performance optimization

### Dependencies:
- Requires: [existing features]
- Impacts: [other components]
- Timeline: [estimated duration]

### Success Criteria:
- [ ] Feature works as specified
- [ ] No regressions in existing functionality
- [ ] Performance within acceptable limits
- [ ] User testing validates requirements

---

個人アプリのメタアーキテクチャパターン

このスキルは、個人アプリ アーキテクト認知アーキテクチャを実装します。

• 知覚：個人アプリの状態、ユーザーエクスペリエンス指標、開発コンテキストを継続的に監視します
• 推論：ユーザーエクスペリエンスのトレードオフを分析し、個人開発の選択肢を評価し、体系的な計画策定を用いて決定します
• 行動：個人アプリ専門スキルに委任し、ユーザーエクスペリエンスの成果を検証します
• 学習：個人開発のナレッジベースを更新し、ユーザーエクスペリエンスの推奨事項を改善します
• 記憶：個人アプリの履歴、ユーザーエクスペリエンスのパターン、開発上の決定を保持します
• 注意：ユーザーの生産性への影響と個人開発の速度に基づいて優先順位を付けます

これにより、ユーザーエクスペリエンスに関するあらゆる決定、実装、個人開発の成果から学習し、時間とともに効果を高める自己改善型の個人アプリ向けアーキテクチャインテリジェンスが実現します。

---

必須のユーザー確認要件

ポリシー：ユーザーの確認なしに修正済みと主張しない

重要：「修正済み」「解決済み」「動作中」「完了」と、問題、バグ、課題について主張する前に、以下の検証プロトコルを必ず実行してください。

ステップ 1：技術的な検証

• 関連するテストをすべて実行します（ビルド、型チェック、ユニットテスト）
• コンソールエラーがないことを確認します
• 修正のスクリーンショットや証拠を取得します

ステップ 2: ユーザーによる確認の依頼

必須: AskUserQuestion ツールを使用して、修正を確認するようユーザーに明示的に依頼します。

"I've implemented [description of fix]. Before I mark this as complete, please verify:
1. [Specific thing to check #1]
2. [Specific thing to check #2]
3. Does this fix the issue you were experiencing?

Please confirm the fix works as expected, or let me know what's still not working."

ステップ 3: ユーザーの確認を待つ

• ユーザーが応答するまで、成功したという主張を進めてはいけません
• ユーザーの確認なしにタスクを「完了」としてマークしてはいけません
• ユーザーの確認なしに「修正済み」「解決済み」「動作中」といった表現を使用してはいけません

ステップ 4: ユーザーのフィードバックに対応する

• ユーザーが確認した場合: 修正を文書化し、完了としてマークします
• ユーザーが問題を報告した場合: デバッグを続行し、確認サイクルを繰り返します

禁止される行為 (ユーザーの確認なし)

• バグが「修正済み」であると主張すること
• 機能が「動作中」であると述べること
• 問題を「解決済み」としてマークすること
• 機能を「完了」と宣言すること
• 修正に関するあらゆる成功の主張

ユーザーによる確認の依頼前に必要な証拠

1. 技術的なテストに合格していること
2. Playwright／スクリーンショットによる視覚的な確認
3. 実行された具体的なテストシナリオ
4. 何が変更されたかの明確な説明

覚えておいてください: 何かが修正されたかどうかについての最終的な判断権はユーザーにあります。例外はありません。