P0-P8: Full V1.0.0 Alpha implementation + audit reports

Implements 123 tasks across 9 phases (T-001..T-809) totaling 146 source files.

Monorepo (P0):
- 7-package Bun + Turborepo + TypeScript monorepo
- dependency-cruiser enforcing 7 forbidden edges + 5 deep-import rules

Contracts (P0):
- 16 type files (ids/error/event/runtime/ipc/task/worker-result/tool/artifact/evidence/project/provider/permission/ui/capability/platform)

Storage & Events (P1):
- DatabaseManager + MigrationRunner (19 tables, 22 indexes, 5 schema_meta seeds)
- 16 repositories (Repository<T,I,U> pattern, INV-1 status columns via EventStore.project only)
- EventSchemaRegistry (54 durable + 7 ephemeral), EventStore, EventBus, EventIngestor
- Project/Session/Artifact/Evidence stores + 8-step Recovery

Tools & Permission (P2):
- PathClassifier (8 categories), CommandRiskAnalyzer (10 categories), SecretRedactor
- PermissionEngine 6-layer evaluation (capability→profile→task_scope→risk→credential→user_prompt)
- ToolRegistry with 20+ tools across fs/shell/git/project/artifact/context/permission/doctor
- CapabilityManifestValidator + CapabilityRegistry

LLM & Context (P3):
- ModelConfigLoader, CapabilityMatrix, AnthropicCanonicalConverter
- AnthropicAdapter + OpenAICompatibleAdapter
- ProviderManager facade
- PromptLayerLoader (L0/L1/L3/L5), CompactionPolicy, ContextAssembler

Worker IPC & Scheduler (P4):
- WorkerProtocol (NDJSON), WorkerProcess (exit codes 0-5), WorkerManager (spawn/handshake)
- WorkerRuntime (INV-3: IPC only, no direct fs/shell/SQLite)
- 5 worker roles (Executor/Reviewer/Debugger/Compactor/ExperienceMiner)
- TaskGraph, WavePlanner, RetryPlanner, AgentMonitor, WorkspaceManager
- Scheduler (state machine), 8-step Recovery

C++ Toolchain (P5):
- DiagnosticParser, CppProjectDetector, CMakeConfigurator, CppBuilder
- CppTestRunner, CppcheckRunner, ClangdClient
- CppToolRegistrar + capability manifest

Projection & TUI (P6):
- ProjectionStore (hydrate/apply/snapshot/subscribe)
- TuiApp + 8 components (Session/Task/Agent/Tool/Diff/Evidence/Permission/Blocker/Hud)
- ProjectionClient in-process ref

Agents & Knowledge (P7):
- MainAgent, ArchitectureDesigner
- DebugKnowledgeStore + LearnedMemoryStore (single-writer, outbox model)
- Role integration wiring

CLI & Doctor & Release (P8):
- Logger + DeveloperLogEncryptor (AES-256-GCM)
- DoctorService (self_bootstrap first)
- RuntimeApp + ServiceRegistry
- 11 CLI commands: run/init/doctor/provider/resume/compact/history/session/restore/e2e/release
- CliEntrypoint + air<TODO>

Audit (in AirPlan/docs/):
- Deepseek开发阶段审计.md (97 findings)
- Opus开发阶段审计.md (140+ findings, 18 P0 blockers)
- MiniMaxM3开发阶段审计.md (18 P0 blockers, focuses on executability)
- AirPlan/TODO.md (technical debt + 42 TODOs by phase)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

packages/llm/src/ModelConfigLoader.ts

@@ -0,0 +1,190 @@
+/**
+ * ModelConfigLoader - Loads model configuration from YAML files
+ *
+ * Implements DD §12.2.
+ * Loads global ~/.air/models.yaml + project config.
+ *
+ * @module packages/llm/src/ModelConfigLoader
+ */
+
+import { readFileSync, existsSync } from 'fs'
+import { resolve, join } from 'path'
+import { homedir } from 'os'
+
+export interface ModelConfig {
+  provider: string
+  model: string
+  api_key?: string
+  base_url?: string
+  max_tokens?: number
+  temperature?: number
+  top_p?: number
+}
+
+export interface ModelConfigSet {
+  global?: Record<string, ModelConfig>
+  project?: Record<string, ModelConfig>
+}
+
+export interface ConfigLoadResult {
+  ok: boolean
+  configs?: ModelConfigSet
+  error?: string
+}
+
+const DEFAULT_CONFIG_PATH = join(homedir(), '.air', 'models.yaml')
+
+export class ModelConfigLoader {
+  private global_config_path: string
+  private project_config_path?: string
+
+  constructor(global_path?: string, project_path?: string) {
+    this.global_config_path = global_path || DEFAULT_CONFIG_PATH
+    this.project_config_path = project_path
+  }
+
+  /**
+   * Load all model configurations.
+   */
+  load(): ConfigLoadResult {
+    const configs: ModelConfigSet = {}
+
+    // Load global config
+    if (existsSync(this.global_config_path)) {
+      try {
+        const content = readFileSync(this.global_config_path, 'utf-8')
+        configs.global = this.parse_yaml(content)
+      } catch (error) {
+        return { ok: false, error: `Failed to load global config: ${error instanceof Error ? error.message : String(error)}` }
+      }
+    }
+
+    // Load project config if specified
+    if (this.project_config_path && existsSync(this.project_config_path)) {
+      try {
+        const content = readFileSync(this.project_config_path, 'utf-8')
+        configs.project = this.parse_yaml(content)
+      } catch (error) {
+        return { ok: false, error: `Failed to load project config: ${error instanceof Error ? error.message : String(error)}` }
+      }
+    }
+
+    return { ok: true, configs }
+  }
+
+  /**
+   * Get config for a specific model by name.
+   */
+  get_model(name: string): ModelConfig | undefined {
+    const result = this.load()
+    if (!result.ok || !result.configs) return undefined
+
+    // Project config takes precedence over global
+    if (result.configs.project?.[name]) {
+      return result.configs.project[name]
+    }
+
+    return result.configs.global?.[name]
+  }
+
+  /**
+   * Validate required fields in a model config.
+   */
+  validate(config: ModelConfig): { valid: boolean; error?: string } {
+    if (!config.provider) {
+      return { valid: false, error: 'provider is required' }
+    }
+    if (!config.model) {
+      return { valid: false, error: 'model is required' }
+    }
+
+    // Provider-specific validation
+    if (config.provider === 'anthropic') {
+      if (!config.api_key && !process.env.ANTHROPIC_API_KEY) {
+        // Warning, not error - might use default credentials
+      }
+    }
+
+    if (config.provider === 'openai' || config.provider === 'openai-compatible') {
+      if (!config.api_key && !process.env.OPENAI_API_KEY) {
+        // Warning
+      }
+    }
+
+    return { valid: true }
+  }
+
+  /**
+   * Simple YAML parser for model configs.
+   * In production, use a proper YAML library.
+   */
+  private parse_yaml(content: string): Record<string, ModelConfig> {
+    const result: Record<string, ModelConfig> = {}
+    const lines = content.split('\n')
+    let current_key = ''
+    let current_config: Partial<ModelConfig> = {}
+
+    for (const line of lines) {
+      const trimmed = line.trim()
+
+      // Skip comments and empty lines
+      if (!trimmed || trimmed.startsWith('#')) continue
+
+      // Check for top-level key (model name)
+      if (trimmed.endsWith(':') && !trimmed.includes(' ')) {
+        // Save previous config
+        if (current_key && current_config.provider) {
+          result[current_key] = current_config as ModelConfig
+        }
+        current_key = trimmed.slice(0, -1)
+        current_config = {}
+        continue
+      }
+
+      // Parse key: value pairs
+      const colon_idx = trimmed.indexOf(':')
+      if (colon_idx > 0) {
+        const key = trimmed.slice(0, colon_idx).trim()
+        const value = trimmed.slice(colon_idx + 1).trim()
+
+        // Remove quotes from value
+        const clean_value = value.replace(/^["']|["']$/g, '')
+
+        switch (key) {
+          case 'provider':
+            current_config.provider = clean_value
+            break
+          case 'model':
+            current_config.model = clean_value
+            break
+          case 'api_key':
+            current_config.api_key = clean_value
+            break
+          case 'base_url':
+            current_config.base_url = clean_value
+            break
+          case 'max_tokens':
+            current_config.max_tokens = parseInt(clean_value, 10)
+            break
+          case 'temperature':
+            current_config.temperature = parseFloat(clean_value)
+            break
+          case 'top_p':
+            current_config.top_p = parseFloat(clean_value)
+            break
+        }
+      }
+    }
+
+    // Save last config
+    if (current_key && current_config.provider) {
+      result[current_key] = current_config as ModelConfig
+    }
+
+    return result
+  }
+}
+
+export function createModelConfigLoader(global_path?: string, project_path?: string): ModelConfigLoader {
+  return new ModelConfigLoader(global_path, project_path)
+}