kenaz 0.0.0-stage → 0.3.2

package/core/dev/jev-eval/test/resilience.test.mjs

@@ -0,0 +1,72 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { setTimeout as delay } from 'node:timers/promises';
+import { evaluateMode, runMatrix } from '../resilience.mjs';
+import { template } from '../cli.mjs';
+import { rules, liveProvider, prediction, MODEL } from '../providers.mjs';
+
+test('offline fault matrix delivers exactly once and distinguishes failure from fallback', async () => {
+  const matrix = await runMatrix(); assert.equal(matrix.count, 27); assert.equal(matrix.promotion_eligible, false);
+  assert.equal(matrix.production_fallback_verified, false); assert.equal(matrix.installed_application_verified, false); assert.equal(matrix.timeouts, 4);
+  for (const o of matrix.observations) {
+    if (o.mode !== 'off' && ['delayed_headers', 'stalled_body'].includes(o.fault)) assert.equal(o.provider_outcome.status, 'timeout', JSON.stringify(o));
+    assert.equal(o.deliveries, 1); assert.equal(o.input_unchanged, true); assert.equal(o.late_output_unchanged, true);
+    if (o.mode === 'off' || o.fault === 'missing_key') { assert.equal(o.transport_calls, 0); assert.equal(o.requests, 0); }
+    else { assert.equal(o.transport_calls, 1); assert.equal(o.requests, 1); }
+    const usesJev = o.mode === 'evaluation-active' && o.fault === 'valid';
+    assert.equal(o.delivered_source, usesJev ? 'jev' : 'baseline'); assert.equal(o.baseline_calls, usesJev ? 0 : 1); assert.equal(o.baseline_equal, !usesJev);
+    if (o.mode !== 'off' && o.fault !== 'valid') assert.notEqual(o.provider_outcome.status, 'ok');
+    assert.equal(o.delivered_status, 'ok');
+  }
+  assert.equal(JSON.stringify(matrix).includes('local-resilience-dummy'), false);
+  for (const status of [401, 422, 429, 529, 500]) assert.ok(matrix.observations.some(o => o.provider_outcome.http_status === status));
+});
+test('off never constructs provider; missing/invalid keys do not reach injected network', async () => {
+  let factoryCalls = 0, network = 0;
+  const off = await evaluateMode(template(), { mode: 'off', providerFactory: () => { factoryCalls++; throw new Error('unused'); } });
+  assert.equal(off.deliveries, 1); assert.equal(factoryCalls, 0);
+  for (const apiKey of ['', ' ', 'not-empty\ninvalid']) {
+    const r = await evaluateMode(template(), { mode: 'evaluation-active', providerFactory: () => liveProvider({ apiKey, fetchImpl: () => { network++; } }) });
+    assert.equal(r.provider_outcome.status, 'missing_key'); assert.equal(r.baseline_calls, 1);
+  }
+  assert.equal(network, 0);
+});
+test('shadow delivers baseline before waiting, late completion never delivers again', async () => {
+  const row = template(), baseline = rules(row); let resolveProvider, calls = 0;
+  const pending = evaluateMode(row, { mode: 'shadow', baseline: () => baseline, deliver: value => { calls++; assert.deepEqual(value, baseline); }, providerFactory: () => () => new Promise(resolve => { resolveProvider = resolve; }) });
+  await delay(0); assert.equal(calls, 1);
+  resolveProvider(prediction(row, 'ok', 0.99)); const result = await pending;
+  assert.equal(calls, 1); assert.deepEqual(result.delivered, baseline);
+});
+test('invalid identity and partial provider scores fall back without mutating input', async () => {
+  const row = template(), before = structuredClone(row);
+  const r = await evaluateMode(row, { mode: 'evaluation-active', providerFactory: () => input => { input.state.message = 'changed'; return prediction(input, 'ok', 0.9); } });
+  assert.equal(r.source, 'baseline'); assert.equal(r.provider_outcome.status, 'invalid'); assert.deepEqual(row, before);
+  const relevance = { ...row, purpose: 'relevance', candidates: [{ id: 'a', text: 'a', grade: 1 }, { id: 'b', text: 'b', grade: 0 }] }; delete relevance.labels;
+  const partial = await evaluateMode(relevance, { mode: 'evaluation-active', providerFactory: () => input => prediction(input, 'ok', { a: 3 }) });
+  assert.equal(partial.source, 'baseline'); assert.equal(partial.provider_outcome.status, 'ok'); assert.equal(partial.baseline_calls, 1);
+});
+test('transport completion after timeout cannot redeliver or replace baseline', async () => {
+  const row = template(), baseline = rules(row); let complete = false, deliveries = 0;
+  const result = await evaluateMode(row, { mode: 'evaluation-active', baseline: () => baseline, deliver: () => { deliveries++; }, providerFactory: () => liveProvider({
+    apiKey: 'local-test-only', timeoutMs: 20, fetchImpl: async () => {
+      await delay(100); complete = true;
+      return new Response(JSON.stringify({ model: MODEL, answers: { correction: { type: 'noul', noul: 0.99 } }, usage: { input_tokens: 1, output_tokens: 1 } }));
+    },
+  }) });
+  assert.equal(result.provider_outcome.status, 'timeout'); assert.equal(complete, false); const snapshot = JSON.stringify(result);
+  await delay(130); assert.equal(complete, true); assert.equal(deliveries, 1); assert.equal(JSON.stringify(result), snapshot); assert.deepEqual(result.delivered, baseline);
+});
+test('baseline rejection propagates without retry or provider activation in shadow', async () => {
+  let calls = 0, providerCalls = 0;
+  await assert.rejects(evaluateMode(template(), { mode: 'shadow', baseline: () => { calls++; throw new Error('baseline_failed'); }, providerFactory: () => { providerCalls++; } }), /baseline_failed/);
+  assert.equal(calls, 1); assert.equal(providerCalls, 0);
+});
+test('non-Error provider exceptions and wrong-model success fail closed', async () => {
+  for (const thrown of [null, 'arbitrary-secret', undefined]) {
+    const result = await evaluateMode(template(), { mode: 'evaluation-active', providerFactory: () => { throw thrown; } });
+    assert.equal(result.source, 'baseline'); assert.equal(result.provider_outcome.status, 'invalid'); assert.equal(result.baseline_calls, 1);
+  }
+  const result = await evaluateMode(template(), { mode: 'evaluation-active', providerFactory: () => rules });
+  assert.equal(result.source, 'baseline'); assert.equal(result.provider_outcome.status, 'invalid');
+});

package/core/dev/jev-eval/test/review.test.mjs

@@ -0,0 +1,61 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, writeFile, readdir, unlink, rmdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { readJsonl } from '../schema.mjs';
+import { exportReview, applyReview, main, datasetHash } from '../review.mjs';
+
+const rows = await readJsonl(new URL('../fixtures/synthetic.jsonl', import.meta.url));
+function filled() {
+  const review = exportReview(rows);
+  for (const item of review.items) {
+    item.reviewed = true; item.reviewer = 'test-attestation-only'; item.reviewed_at = '2026-09-20T12:00:00Z';
+    if (item.purpose === 'correction') item.decision.correction = false;
+    else for (const grade of item.decision.grades) grade.grade = 2;
+  }
+  return review;
+}
+test('blinded export contains context but no original gold/provenance/predictions', () => {
+  const before = JSON.stringify(rows), review = exportReview(rows);
+  assert.equal(review.items.length, rows.length); assert.equal(JSON.stringify(rows), before);
+  for (const item of review.items) {
+    for (const key of ['labels', 'provenance', 'model', 'scores', 'grade']) assert.equal(Object.hasOwn(item, key), false);
+    assert.equal(item.reviewed, false); assert.equal(item.reviewer, null);
+    if (item.purpose === 'correction') assert.equal(item.decision.correction, null);
+    else { assert.ok(item.candidates.every(c => Object.keys(c).sort().join() === 'id,text')); assert.ok(item.decision.grades.every(c => c.grade === null)); }
+  }
+});
+test('complete attested review applies separate labels preserving input identity and source', () => {
+  const before = JSON.stringify(rows), result = applyReview(rows, filled());
+  assert.equal(JSON.stringify(rows), before);
+  for (let i = 0; i < rows.length; i++) {
+    const { provenance, labels, candidates, ...original } = rows[i];
+    const { provenance: p, labels: l, candidates: c, ...actual } = result[i];
+    assert.deepEqual(actual, original); assert.equal(p.source, provenance.source); assert.equal(p.annotation, 'human_verified');
+    if (l) assert.equal(l.correction, false); else assert.ok(c.every(x => x.grade === 2));
+  }
+  const shuffled = filled(); shuffled.items.reverse(); assert.deepEqual(applyReview(rows, shuffled), result);
+});
+test('rejects incomplete, stale, duplicated, tampered or unauthored reviews', () => {
+  assert.throws(() => applyReview(rows, exportReview(rows)), /unreviewed/);
+  const changes = [r => r.items.pop(), r => r.items[1] = r.items[0], r => r.dataset_hash = 'stale', r => r.review_version = 'v2', r => r.model_scores = [], r => r.items[0].context.message = 'tampered', r => r.items[0].project_id = 'other', r => r.items[0].state_hash = 'bad', r => r.items[0].reviewed = false, r => r.items[0].reviewer = ' ', r => r.items[0].reviewed_at = '2026-02-30T12:00:00Z', r => r.items[0].decision.correction = null, r => r.items[0].decision.extra = true, r => r.items[8].decision.grades[0].id = 'unknown', r => r.items[8].decision.grades[0].grade = 1.5, r => r.items[8].decision.grades[1].id = r.items[8].decision.grades[0].id];
+  for (const change of changes) { const review = filled(); change(review); assert.throws(() => applyReview(rows, review)); }
+  const changedDataset = structuredClone(rows); changedDataset[0].labels.correction = !changedDataset[0].labels.correction;
+  assert.notEqual(datasetHash(rows), datasetHash(changedDataset)); assert.throws(() => applyReview(changedDataset, filled()), /stale/);
+});
+test('CLI exclusively creates outputs, rejects partial reviews without output, preserves sources', async t => {
+  const dir = await mkdtemp(join(tmpdir(), 'jev-review-test-'));
+  t.after(async () => { for (const name of await readdir(dir)) await unlink(join(dir, name)); await rmdir(dir); });
+  const dataset = join(dir, 'data.jsonl'), review = join(dir, 'review.json'), out = join(dir, 'reviewed.jsonl');
+  await writeFile(dataset, rows.map(r => JSON.stringify(r)).join('\n')); const original = await readFile(dataset, 'utf8');
+  assert.equal((await main(['export', '--dataset', dataset, '--out', review])).count, rows.length);
+  await assert.rejects(main(['export', '--dataset', dataset, '--out', review]), /EEXIST/);
+  await assert.rejects(main(['apply', '--dataset', dataset, '--reviews', review, '--out', out]), /unreviewed/);
+  assert.equal((await readdir(dir)).includes('reviewed.jsonl'), false);
+  await writeFile(review, JSON.stringify(filled()));
+  await main(['apply', '--dataset', dataset, '--reviews', review, '--out', out]);
+  assert.equal((await readJsonl(out))[0].provenance.annotation, 'human_verified');
+  await assert.rejects(main(['apply', '--dataset', dataset, '--reviews', review, '--out', dataset]), /overwrite/);
+  assert.equal(await readFile(dataset, 'utf8'), original); assert.equal((await readdir(dir)).some(x => x.endsWith('.tmp')), false);
+});

package/core/dev/pipeline/LOCK_STATE.json

@@ -0,0 +1,4 @@
+{
+  "locks": [],
+  "last_updated": "2026-02-15T04:08:31.678821"
+}

package/core/dev/pipeline/OPTIMIZATION_PROPOSALS.json

@@ -0,0 +1,32 @@
+{
+  "version": "1.0.0",
+  "proposals": [
+    {
+      "id": "PROP_001",
+      "title": "Dual Heimdall trigger paths lack deduplication - risk of concurrent sessions per commit",
+      "description": "Both /api/heimdall/trigger and /api/code_watch/trigger dispatch headless.js with --skill=heimdall with identical behavior. No in-flight tracking exists. Concurrent calls for the same commit produce duplicate Heimdall sessions and potentially duplicate proposals. Recommend adding a per-project in-flight lock keyed by project_path+commit_sha in both trigger handlers, or unify: code_watch/trigger delegates internally to heimdall/trigger logic.",
+      "category": "code_quality",
+      "priority": "P2",
+      "status": "pending",
+      "diffs": [],
+      "affected_files": [
+        "dashboard/src-tauri/src/infrastructure/http_server/routes/heimdall.rs",
+        "dashboard/src-tauri/src/infrastructure/http_server/routes/code_watch.rs"
+      ],
+      "estimated_hours": 2.0,
+      "source": "code_watch:risk_rune",
+      "related_task_id": null,
+      "created_at": "2026-03-19T06:28:19.215948+00:00",
+      "updated_at": null,
+      "resolved_at": null,
+      "metadata": null
+    }
+  ],
+  "statistics": {
+    "total": 1,
+    "pending": 1,
+    "accepted": 0,
+    "ignored": 0
+  },
+  "last_updated": "2026-03-19T06:28:19.215948+00:00"
+}

package/core/dev/pipeline/PHASE3_PLANNING_SUMMARY.md

@@ -0,0 +1,338 @@
+# Kenaz Cortex V2 - Phase 3 規劃總結
+
+> **規劃日期**: 2026-02-07
+> **規劃者**: Architect Agent
+> **狀態**: ✅ PLANNING COMPLETE
+> **下一步**: 等待用戶確認並啟動開發
+
+---
+
+## 📊 執行總結
+
+Phase 3 架構設計已完成！我們將 Kenaz Cortex V2 從「智能檢索系統」升級為「生產就緒的動態智能系統」。
+
+### 核心目標
+
+| 維度 | Phase 2 | Phase 3 目標 | 改善幅度 |
+|------|---------|-------------|---------|
+| **快取容量** | 100 項 | 10,000+ 項 | **+100x** |
+| **快取共享** | ❌ 單機 | ✅ 團隊共享 | **NEW** |
+| **首次查詢** | 1.5s (冷啟動) | 0.6s (預熱) | **-60%** |
+| **變更感知** | ❌ 無 | ✅ 實時追蹤 | **NEW** |
+| **快取失效** | ⏰ 手動 TTL | ✅ 自動智能失效 | **NEW** |
+| **整體性能** | - | > +20% | **+20%** |
+
+---
+
+## 🏗️ 四大核心系統
+
+### 1. Layer 4: 動態追蹤層 🎯
+
+**解決什麼問題？**
+- Layer 1-3 無法感知文件變更
+- 文件修改後快取已過時但無法自動失效
+- 缺乏全局視角
+
+**提供什麼？**
+- ✅ 實時監控文件系統和 Git 變更（File Watcher + Git Monitor）
+- ✅ 智能分析變更影響範圍（BFS 依賴鏈，最大深度 3）
+- ✅ 自動失效相關快取（影響分析 → 快取失效）
+- ✅ 動態維護專案架構視圖
+
+**核心組件**:
+```
+File Watcher (watchdog) → Change Analyzer (BFS) → Cache Invalidator
+Git Monitor (GitPython) ↗
+```
+
+**性能指標**:
+- 變更追蹤延遲 < 500ms
+- 快取失效準確率 > 95%
+- CPU 佔用 < 5%
+
+---
+
+### 2. 分佈式快取系統 🌐
+
+**解決什麼問題？**
+- 單機快取容量有限（100 項）
+- 無法團隊共享
+- 進程重啟後快取丟失
+
+**兩層快取架構**:
+```
+L1 Local Cache (100 項, LRU, <1ms)
+   ↓ miss
+L2 Redis Cache (10,000+ 項, 團隊共享, <10ms)
+```
+
+**核心特性**:
+- ✅ L1 → L2 兩層查詢策略
+- ✅ 同時寫入 L1 + L2
+- ✅ L1 回填機制（L2 命中時回填 L1）
+- ✅ Redis 連接失敗時優雅降級
+
+**容量提升**: 100 項 → 10,000+ 項 (+100x)
+
+---
+
+### 3. 智能快取預熱系統 🚀
+
+**解決什麼問題？**
+- 用戶首次查詢必須等待完整 RAG 檢索（1-2 秒）
+- 高頻查詢每次冷啟動都需重複計算
+
+**預熱流程**:
+```
+專案啟動 → 分析歷史查詢（7 天）→ 識別高頻模式（Top 20）→ 預生成 Context
+```
+
+**優先級計算**:
+```python
+priority = frequency * (1.0 / days_since_last_use)
+```
+
+**預熱效果**:
+- 首次查詢命中率：0% → 60%+
+- 預熱完成時間：< 5 秒
+- 首次查詢延遲：1.5s → 0.6s (-60%)
+
+---
+
+### 4. 自適應優化引擎 🔧
+
+**解決什麼問題？**
+- 固定 TTL（24h）無法適應不同文件的修改頻率
+- 快取資源分配不智能
+
+**自適應 TTL 策略**:
+| 修改頻率 | 30天修改次數 | TTL | 適用場景 |
+|---------|-------------|-----|---------|
+| 高頻 | > 50 次 | 1 小時 | 活躍開發文件 |
+| 中頻 | 10-50 次 | 6 小時 | 正常維護文件 |
+| 低頻 | < 10 次 | 24 小時 | 穩定文件 |
+
+**動態資源分配**:
+- 高頻查詢（> 100 次）→ 分配 2x 快取空間
+- 低頻查詢 → 更快驅逐
+
+---
+
+## 📋 任務拆解（8 個任務）
+
+| ID | 任務名稱 | 複雜度 | 工時 | Agent | 依賴 | 可並行 |
+|----|---------|--------|------|-------|------|--------|
+| **TASK_134** | Layer 4 - 文件監控器 | Medium | 16h | backend | - | ✅ |
+| **TASK_135** | Layer 4 - Git 變更監控器 | Medium | 12h | backend | - | ✅ |
+| **TASK_136** | Layer 4 - 變更影響分析器 | Complex | 20h | backend | 134, 135 | ❌ |
+| **TASK_137** | Layer 4 - 智能快取失效器 | Medium | 16h | backend | 136 | ❌ |
+| **TASK_138** | 分佈式快取系統（Redis） | Complex | 24h | backend | - | ✅ |
+| **TASK_139** | 智能快取預熱系統 | Medium | 16h | backend | 138 | ❌ |
+| **TASK_140** | 自適應優化引擎 | Medium | 12h | backend | 136, 138 | ❌ |
+| **TASK_141** | Phase 3 整合測試與文檔 | Medium | 20h | qa | 134-140 | ❌ |
+
+**總工時**: 136 小時
+**可並行任務**: 3 個（TASK_134, TASK_135, TASK_138）
+**預計完成時間**: 4 週
+
+---
+
+## 🔀 依賴關係圖
+
+```
+並行開始（Week 1）：
+        TASK_134 (16h) ────┐
+                           ├──> TASK_136 (20h) ──> TASK_137 (16h) ──┐
+        TASK_135 (12h) ────┘                                        │
+                                                                    │
+        TASK_138 (24h) ──> TASK_139 (16h) ─────────────────────────┼──> TASK_141 (20h)
+                           │                                        │
+                           └──> TASK_140 (12h) ─────────────────────┘
+
+Week 1: TASK_134, TASK_135, TASK_138 (並行)
+Week 2: TASK_136, TASK_139 (並行)
+Week 3: TASK_137, TASK_140 (並行)
+Week 4: TASK_141 (整合測試)
+```
+
+---
+
+## 📊 性能目標與驗收標準
+
+### 性能目標
+
+| 指標 | Phase 2 | Phase 3 目標 | 改善幅度 |
+|------|---------|-------------|---------|
+| 快取容量 | 100 項 | 10,000+ 項 | +100x |
+| 快取命中率 | 87.5% | 90%+ | +2.5% |
+| 首次查詢延遲 | 1.5s | 0.6s | -60% |
+| 變更追蹤延遲 | N/A | < 500ms | NEW |
+| 快取失效準確率 | N/A | > 95% | NEW |
+| 預熱完成時間 | N/A | < 5s | NEW |
+| 整體性能提升 | - | > 20% | +20% |
+
+### 驗收標準（TASK_141）
+
+**必須達成**:
+- ✅ 所有 E2E 測試通過
+- ✅ Layer 4 追蹤延遲 < 500ms
+- ✅ 分佈式快取命中率 > 80%
+- ✅ 預熱首次命中率 > 60%
+- ✅ 自適應 TTL 效果驗證
+- ✅ 測試覆蓋率 > 85%
+
+**期望達成**:
+- 🎯 整體性能提升 > 20%（相比 Phase 2）
+- 🎯 Redis 連接失敗時優雅降級
+- 🎯 並發場景（10+ 用戶）穩定性
+
+---
+
+## 📦 已交付成果
+
+### 1. 任務定義文件（8 個）
+- ✅ `TASK_134_cortex_v2_phase3_file_watcher.yaml`
+- ✅ `TASK_135_cortex_v2_phase3_git_monitor.yaml`
+- ✅ `TASK_136_cortex_v2_phase3_change_analyzer.yaml`
+- ✅ `TASK_137_cortex_v2_phase3_cache_invalidator.yaml`
+- ✅ `TASK_138_cortex_v2_phase3_distributed_cache.yaml`
+- ✅ `TASK_139_cortex_v2_phase3_cache_prewarming.yaml`
+- ✅ `TASK_140_cortex_v2_phase3_adaptive_optimizer.yaml`
+- ✅ `TASK_141_cortex_v2_phase3_integration_testing.yaml`
+
+### 2. 架構設計文檔
+- ✅ `kenaz-cortex/docs/V2_PHASE3_ARCHITECTURE.md` (完整架構設計)
+
+### 3. Pipeline 更新
+- ✅ `dev/pipeline/TASK_QUEUE.json` (新增 8 個任務)
+  - pending: 5 → 13 (+8)
+  - total: 30 → 38 (+8)
+
+### 4. Git Commit
+- ✅ Commit Hash: `c795b53`
+- ✅ Commit Message: "[Phase 3] Kenaz Cortex V2 架構設計完成 🏗️"
+
+---
+
+## 🚀 啟動方式
+
+### 方式一：並行執行（推薦，最快）
+```bash
+# 同時啟動 3 個獨立任務（Week 1）
+/dev 並行 TASK_134 TASK_135 TASK_138
+```
+
+**預期結果**:
+- 3 個 Agent 同時執行
+- Week 1 完成 52 小時工作量
+- 實際耗時 ~24 小時（最長任務時間）
+
+### 方式二：單任務執行（順序）
+```bash
+# 逐個執行
+/dev TASK_134  # 16h
+/dev TASK_135  # 12h
+/dev TASK_138  # 24h
+```
+
+### 方式三：手動分配（細粒度控制）
+```bash
+# 調用特定 Agent
+/後端 TASK_134
+```
+
+---
+
+## 📚 相關文檔
+
+| 文檔 | 路徑 | 用途 |
+|------|------|------|
+| **Phase 3 架構設計** | `kenaz-cortex/docs/V2_PHASE3_ARCHITECTURE.md` | 完整技術設計 |
+| **Phase 2 完成報告** | `kenaz-cortex/docs/V2_PHASE2_COMPLETE.md` | 當前狀態基準 |
+| **系統架構** | `kenaz-cortex/docs/ARCHITECTURE.md` | 整體架構 |
+| **Task Queue** | `dev/pipeline/TASK_QUEUE.json` | 任務佇列 |
+
+---
+
+## 🔍 風險與緩解
+
+| 風險 | 影響 | 緩解策略 | 優先級 |
+|------|------|---------|--------|
+| **Redis 依賴** | 無 Redis 無法使用 L2 快取 | 優雅降級，只使用 L1 | P1 |
+| **文件監控性能** | 大型專案監控成本高 | 輪詢模式 + 白名單過濾 | P2 |
+| **依賴圖構建** | 初始構建耗時長 | 異步構建 + 增量更新 | P2 |
+| **快取一致性** | 分佈式環境快取不一致 | Layer 4 自動失效機制 | P1 |
+
+---
+
+## 📈 Phase 回顧（完整旅程）
+
+### Phase 1: 四層架構基礎（✅ 已完成）
+- Layer 1: Rule-First（規則優先）
+- Layer 2: Architecture（架構感知）
+- 配置系統（Pydantic + YAML）
+- 測試覆蓋率 90%+
+
+**成果**: 建立了混合檢索的基礎架構
+
+---
+
+### Phase 2: 智能檢索增強（✅ 已完成）
+- Layer 3: Smart Retrieval（RAG + 依賴擴展 + 相似檢索）
+- LRU 快取機制（100 項）
+- 異步處理（加速 75%）
+- 性能優化（響應時間 -57%，記憶體 -40%）
+
+**成果**: 實現了智能檢索和性能優化
+
+---
+
+### Phase 3: 生產就緒與智能優化（📐 規劃完成）
+- Layer 4: Dynamic Tracking（實時追蹤）
+- 分佈式快取（L1 + L2）
+- 智能預熱（首次命中率 60%+）
+- 自適應優化（動態 TTL）
+
+**目標**: 實現生產級別的動態智能系統
+
+---
+
+## ✅ 下一步行動
+
+### 立即行動（用戶確認後）
+1. **選擇啟動方式**：
+   - 推薦：並行執行 3 個任務（最快）
+   - 或：逐個執行（更穩定）
+
+2. **預估時間軸**：
+   - Week 1: 並行 3 任務（TASK_134, 135, 138）
+   - Week 2: 並行 2 任務（TASK_136, 139）
+   - Week 3: 並行 2 任務（TASK_137, 140）
+   - Week 4: 整合測試（TASK_141）
+
+3. **資源需求**：
+   - 3 個並行 Backend Agent（Week 1）
+   - 1 個 QA Agent（Week 4）
+   - Redis 環境（本地或遠端）
+
+---
+
+## 🎯 成功定義
+
+**Phase 3 成功 = 當所有指標達成時**:
+- ✅ 8/8 任務完成
+- ✅ 快取容量提升 100x
+- ✅ 首次查詢延遲減少 60%
+- ✅ 變更追蹤 < 500ms
+- ✅ 快取失效準確率 > 95%
+- ✅ 整體性能提升 > 20%
+- ✅ 測試覆蓋率 > 85%
+
+**當這些達成時，Kenaz Cortex V2 將成為生產就緒的動態智能系統！** 🚀
+
+---
+
+**規劃者**: Architect Agent
+**規劃時間**: 2026-02-07 06:30-07:00 (30 分鐘)
+**文檔版本**: v1.0.0
+**狀態**: ✅ READY FOR EXECUTION

package/core/dev/pipeline/PIPELINE_CONFIG.json

@@ -0,0 +1,46 @@
+{
+  "pipeline_name": "New Project Pipeline",
+  "version": "1.0.0",
+  "created_at": "2026-01-29",
+
+  "settings": {
+    "auto_create_log": true,
+    "auto_update_progress": true,
+    "max_task_duration_hours": 4,
+    "priority_levels": ["P0", "P1", "P2", "P3"]
+  },
+
+  "paths": {
+    "tasks": "dev/pipeline/tasks/",
+    "logs": "dev/pipeline/logs/",
+    "completed": "dev/pipeline/completed/",
+    "progress": "dev/pipeline/PROGRESS.md",
+    "spec": "dev/PRODUCT_SPEC_FOR_AI.md",
+    "agent_guide": "dev/DEV_AGENT_GUIDE.md"
+  },
+
+  "task_status": {
+    "pending": "待執行",
+    "in_progress": "執行中",
+    "completed": "已完成",
+    "blocked": "已阻塞",
+    "cancelled": "已取消"
+  },
+
+  "log_template": {
+    "include_file_changes": true,
+    "include_test_results": true,
+    "include_next_steps": true
+  },
+
+  "integrations": {
+    "product_spec": "dev/PRODUCT_SPEC_FOR.md",
+    "related_docs": [
+      "dev/COMPONENT_CREATION_SOP.md",
+      "dev/AI_BLOCK_GENERATOR_GUIDE.md",
+      "dev/AI_UGC_COMPLETE.md",
+      "dev/INTERACTIVE_FEATURES_GUIDE.md",
+      "dev/PAYMENT_INTEGRATION.md"
+    ]
+  }
+}

package/core/dev/pipeline/PROGRESS.md

@@ -0,0 +1,113 @@
+# Pipeline Progress Tracking
+
+## Last Update
+- **Time**: 2026-02-24 00:00
+- **Agent**: Product Manager Agent
+- **Action**: 建立 3 個新任務 — Self-Enhancement 獨立化（TASK_248~250）
+  - **TASK_248**: Rust 後端：獨立 Self-Enhancement Service（整點定時 + Proposal 輸出）(P1, 6h)
+  - **TASK_249**: 前端：Self-Enhancement 獨立 Toggle Card (P1, 3h)
+  - **TASK_250**: 清理：解耦 Self-Enhancement 與排程器 (P2, 2h)
+  - 依賴關係: TASK_249 → TASK_248, TASK_250 → TASK_248
+  - 總預估工時: 11h
+
+---
+
+## Statistics
+
+### Current Queue Status（舊系統 TASK_QUEUE.json）
+```
+Active Tasks: 0
+Pending: 0 (0%)
+In Progress: 0 (0%)
+Completed: 8 (100%)
+Blocked: 0 (0%)
+```
+
+### New System Status（新系統 .collaboration/tasks/）
+```
+Total: 15（最近批次）
+Pending: 3 (TASK_248, TASK_249, TASK_250)
+In Progress: 0
+Completed: 12 (TASK_188~196, TASK_197~199)
+Blocked: 0
+Cancelled: 0
+```
+
+### Historical Record (from .memory/ + completed/)
+```
+Completed Tasks: 187+
+Total Historical: 187+
+```
+
+### Overall Progress (累積制)
+```
+Total Tasks: 187+ (佇列 8 + 歷史 179+)
+Completed: 187+ (100%)
+Active: 0 (0%)
+```
+
+**說明**：統計採用**累積制**，TASK_QUEUE.json 只保留活躍任務，已完成任務封存於 `.memory/COMPLETED_TASKS.json` 和 `dev/pipeline/completed/`
+
+---
+
+## Current Queue
+
+**佇列狀態**: 3 個待處理任務
+
+### Pending Tasks (Self-Enhancement 獨立化)
+
+| Task ID | Title | Agent | Priority | Est. Hours | Dependencies |
+|---------|-------|-------|----------|------------|--------------|
+| TASK_248 | 獨立 Self-Enhancement Service（整點定時 + Proposal 輸出）| backend | P1 | 6h | - |
+| TASK_249 | Self-Enhancement 獨立 Toggle Card | frontend | P1 | 3h | TASK_248 |
+| TASK_250 | 解耦 Self-Enhancement 與排程器 | frontend | P2 | 2h | TASK_248 |
+
+**Total Pending**: 3 任務 (約 11h)
+
+### Recently Completed (F-020: Platform Adapter 架構統一)
+
+| Task ID | Title | Agent | Priority | Completed At |
+|---------|-------|-------|----------|--------------|
+| TASK_180 | 移除 Quick Actions 的 Single Agent Panel | frontend | P2 | 2026-02-15 01:42 |
+| TASK_181 | 修復 PTY Server UTF-8 多字節字元截斷問題 | frontend | P1 | 2026-02-14 16:44 |
+| TASK_182 | 修復 Scheduler Active Agents 殘留顯示問題 | frontend | P1 | 2026-02-15 01:30 |
+| TASK_183 | 建立 PlatformAdapter 介面 + TauriAdapter + WebAdapter | frontend | P0 | 2026-02-15 12:00 |
+| TASK_184 | 重構 api.ts 改用 PlatformAdapter | frontend | P1 | 2026-02-15 12:00 |
+| TASK_185 | 合併 Mobile 組件到主佈局（響應式統一） | frontend | P1 | 2026-02-15 12:00 |
+| TASK_186 | 移除 Electron 相關代碼 + 清理 | frontend | P2 | 2026-02-15 12:00 |
+| TASK_187 | QA 測試 Platform Adapter 架構統一 | frontend | P1 | 2026-02-15 12:00 |
+
+**Total Completed**: 8 任務 (約 8.5h)
+
+---
+
+## Recent Activity
+
+| Date | Event | Description |
+|------|-------|-------------|
+| 2026-02-24 00:00 | 📋 Tasks Created | **Self-Enhancement 獨立化！** 3 個任務（TASK_248~250, 11h）- 從排程器拆出為獨立服務，整點定時 + Proposal 輸出 |
+| 2026-02-19 10:35 | ✅ Task Completed | **TASK_199** 系統文檔更新：Formation 調度系統（整合新任務系統，loader.js 三層 fallback）（實際 0.3h）|
+| 2026-02-19 10:35 | ✅ Task Completed | **TASK_197** 系統文檔更新：.collaboration 新任務系統（驗證完整性）（實際 0.3h）|
+| 2026-02-19 10:30 | ✅ Task Completed | **TASK_198** 系統文檔更新：dev/pipeline 舊任務系統（標記為 Legacy，引導遷移）（實際 0.3h）|
+| 2026-02-19 00:15 | ✅ Task Completed | **TASK_192** 系統文檔：Formation 多陣型調度系統（實際 0.3h）|
+| 2026-02-19 00:10 | ✅ Task Completed | **TASK_195** 系統文檔：dev/pipeline 舊任務系統（實際 0.3h）|
+| 2026-02-18 23:50 | ✅ Task Completed | **TASK_194** 系統文檔：.collaboration 新任務系統（實際 0.3h）|
+| 2026-02-15 12:00 | 📋 Tasks Created | **F-020！** Platform Adapter 架構統一（4 個任務，20h）- 以 Tauri 為主版本，消除 if/else 分支 |
+| 2026-02-15 01:00 | 🐛 Bug Reported | **TASK_182** Scheduler Active Agents 殘留問題（Race Condition）|
+| 2026-02-15 00:00 | 📋 Tasks Created | **TASK_180 + TASK_181** UI 優化 + PTY UTF-8 修復（2 個任務，3h）|
+| 2026-02-13 12:00 | 📋 Tasks Created | **F-019！** Kenaz Cortex Panel 優化（5 個任務，18h）- 移除 RAG Status + 修復 404 + Memory 切換 + QA |
+| 2026-02-12 22:10 | 📋 Tasks Created | **F-018 Phase 2！** Cortex RAG 品質優化（5 個任務，20h）- YAML/MD Chunker + 多語言 Embedding + 噪音過濾 |
+| 2026-02-12 21:30 | 🧹 Queue Cleanup | 精簡佇列，只保留 F-018 的 6 個任務，其餘移至 completed/ |
+| 2026-02-12 00:00 | 📋 Tasks Created | **F-018 Phase 1 建立！** 結構化 RAG 精準度優化（6 個任務，30h）- Symbol Index + Module Summary + Map-Reduce |
+| 2026-02-10 00:12 | 🔀 Task Split | TASK_146 拆分為 3 階段，TASK_151 已建立（Phase 1） |
+| 2026-02-09 23:28 | 📦 Archive | 33 個已完成任務封存到 .memory/ |
+
+---
+
+## Notes
+
+- **Archive Location**: `.memory/COMPLETED_TASKS.json` 包含所有已完成任務的元數據
+- **Task Files**:
+  - Pending: `dev/pipeline/tasks/`
+  - Completed: `dev/pipeline/completed/`
+- **Backups**: `dev/pipeline/backups/` 保留任務文件備份