kenaz 0.3.10 → 0.3.12

package/core/.claude/skills/code_reviewer/SKILL.md

@@ -232,7 +232,6 @@ description: 程式碼審查、三級問題分類（Blocker/Suggestion/Nit）、
 
 | Mutation | Counterpart | 缺失嚴重度 |
 |----------|-------------|-----------|
-| `hippocampus_episode_start` | `hippocampus_episode_close` | leak（episode 永不歸檔） |
 | `task-api.js claim` | `task-api.js complete` 或 `move blocked` | orphan（task 卡在 active/） |
 | `addEventListener` | `removeEventListener` | leak（listener 記憶體洩漏） |
 | `setInterval` | `clearInterval` | leak（定時器持續觸發） |

package/core/.claude/skills/code_reviewer/patterns.yaml

@@ -17,14 +17,6 @@ mutation_counterpart:
   #   orphan = logical state / lifecycle not terminated
 
   pairs:
-    - pair: hippocampus_episode
-      mutation: 'hippocampus_episode_start'
-      counterpart: 'hippocampus_episode_close'
-      severity: leak
-      rationale: 'episode never closed -> consolidation never fires, unarchived memory accumulates'
-      grep_mutation: 'hippocampus_episode_start'
-      grep_counterpart: 'hippocampus_episode_close'
-
     - pair: task_lifecycle
       mutation: 'task-api.js claim'
       counterpart: 'task-api.js complete | task-api.js move'

package/core/.claude/skills/dev_agent/SKILL.md

@@ -256,8 +256,6 @@ description: 開發協調、Pipeline管理、任務執行、進度追蹤、Agent
 | `kenaz_lsp_references` | 所有引用 / 修改影響範圍 | 修改前評估 blast radius |
 | `kenaz_lsp_definition` | 定義位置 | 跳到宣告處 |
 | `kenaz_lsp_symbols` | 檔案內 symbol 列表 | 了解檔案結構 |
-| `synapse_recall` | 歷史 rune / 已知風險 | 修改前召回 |
-| `synapse_status` | 記憶系統狀態 | 任務開始前檢查 |
 
 文字與概念搜尋用 Grep / Glob。
 
@@ -281,8 +279,7 @@ description: 開發協調、Pipeline管理、任務執行、進度追蹤、Agent
 **在開始任何開發任務前，建議執行：**
 
 1. **獲取專案 Context**：
-   - 使用 `synapse_status` 了解記憶系統狀態
-   - 使用 `synapse_recall` 召回相關已知風險與決策
+   - 讀取任務卡與 `kenaz learn list` 的相關教訓
 
 2. **搜索相關代碼**：
    - 使用 Grep / Glob 找到相關實現
@@ -335,10 +332,10 @@ description: 開發協調、Pipeline管理、任務執行、進度追蹤、Agent
 2. 重新讀取 Skill 文件
 3. 如果問題持續，直接應用該 Agent 的核心職責邏輯
 
-### LSP / Synapse 查詢失敗時
+### LSP 查詢失敗時
 1. 繼續執行任務（降級為 Grep/Glob）
 2. 確認 Dashboard 已啟動（依賴 Rust HTTP server on port 18080）
-3. 使用 `synapse_status` 檢查記憶系統狀態
+3. 使用 `kenaz_ping` 檢查服務狀態
 
 ---
 

package/core/.claude/skills/heimdall/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: Heimdall
-description: 代碼疆域守望者 — git 驅動的代碼健康審查（kenaz_lsp_callers + synapse_recall），生成 OptimizationProposal；記憶健康僅記錄趨勢，不做 KEEP/REVERT
+description: 代碼疆域守望者 — git 驅動的代碼健康審查（kenaz_lsp_callers），生成 OptimizationProposal；記憶健康僅記錄趨勢，不做 KEEP/REVERT
 ---
 
 # Heimdall ᚺ — 守望者
@@ -39,17 +39,16 @@ trigger=manual target_symbol=<SYMBOL> project_path=<PATH>
 
 ### Attention Trigger
 
-`trigger=attention`（舊的注意力聚合工具已移除）：改以 git 近期變更檔 + 已知 rune 作為調查起點。
+`trigger=attention`（舊的注意力聚合工具已移除）：改以 git 近期變更檔 + 作為調查起點。
 
 1. **取得焦點**：`git log --since=7.days --name-only` 統計最常被修改的檔案（top 15）→ `kenaz_lsp_symbols(file)` 取得其中的 symbols
 2. **深度調查每個 symbol**：
    - `kenaz_lsp_references(symbol, depth=2)` → 爆炸半徑
-   - `synapse_recall(query=symbol)` → 已知風險/歷史 rune
    - `kenaz_lsp_callers(symbol)` → 呼叫者
-3. **交叉比對**：合成 blast_radius + known_risks + callers → 產生 finding
-4. **嚴重性分級**：references >= 20 或有未修復 risk rune → HIGH，>= 8 → MEDIUM，else → LOW
+3. **交叉比對**：合成 blast_radius + callers → 產生 finding
+4. **嚴重性分級**：references >= 20 → HIGH，>= 8 → MEDIUM，else → LOW
 5. **空結果**：若無近期變更焦點 → 輸出 `ᚺ Heimdall: clean scan. No attention signals.` 並結束
-6. **降級**：LSP 不可用 → 降級到 `scheduled_trigger` 流程（Grep/Glob + synapse_recall）
+6. **降級**：LSP 不可用 → 降級到 `scheduled_trigger` 流程（Grep/Glob）
 
 ---
 

package/core/.claude/skills/huginn/SKILL.md

@@ -25,58 +25,40 @@ Converting an advisory into a task is **Ansuz exclusive decision**, and Ansuz MU
 
 1. Parse context block: `trigger`, `project_path`, `focus` (optional), `query` (optional)
 2. Confirm `project_path` is set -- abort if missing
-3. Call `synapse_status({ projectPath: project_path })` -- if unavailable, output:
-   `Huginn: Synapse unavailable. Cannot think without perception. Abort.` and exit
+3. (memory probe removed in TASK_2411 -- Huginn perceives code, tasks, Heimdall and wishes only)
 4. **Read loop mode** -- read `{project_path}/.kenaz/loop/loop.json` (fallback: `.kenaz/loop.json`, then `.collaboration/loop.json`).
-   Canonical writer: `readLoopConfig` in `.formation/tools/post-complete/health.js:28`.
    If no file found, default to `{ mode: "manual" }`.
    Store as `loop_mode` ("manual" | "auto"). Loop mode read is harmless; output routing is identical for both branches -- advisory file only.
 5. **Sanity cap** -- no quota API call needed. Huginn targets <= 5 advisories per run (quality cap, not a hard abort).
-6. Output: `trigger_type`, `loop_mode`, `synapse_available`
+6. Output: `trigger_type`, `loop_mode`
 
 ---
 
 ## Phase 1 - Perceive (parallel data collection)
 
-Collect raw signals from 7 sources. All MCP calls MUST include `projectPath`.
+Collect raw signals from 5 sources. All MCP calls MUST include `projectPath`.
 
 ### 1a. Code Perception
 git log hot files (last 14 days), Grep for TODO/FIXME/HACK, kenaz_lsp_references on the top hot symbols
 Output: graph_signals (name kept for downstream phases)
 
-### 1b. Cognitive Perception
-synapse_recall, synapse_sigils
-- **COGNITIVE DEBT pre-emption**: For each hot symbol from 1a with zero runes returned by synapse_recall AND a high kenaz_lsp_references count:
-  tag it as COGNITIVE DEBT in cognitive_signals. In Phase 4, draft an insight rune at confidence 0.5
-  for the top-1 COGNITIVE DEBT symbol (draft only). Do NOT re-propose these symbols if they appear in
-  `.kenaz/huginn-proposed-symbols.json` within the last 30 days (see Phase 3 Repeat Guard).
-Output: cognitive_signals
-
-### 1c. Episodic Perception
-hippocampus_episode_recall difficulties, hippocampus_episode_recall successes
-Output: episodic_signals
-
-### 1d. Cross-Project Perception (if Cortex available)
-cortex_recall architecture patterns
-Output: cross_project_signals
-
-### 1e. Task Perception
+### 1b. Task Perception
 - Read .kenaz/tasks/done/ or .collaboration/tasks/done/ last 30 days
 - Read blocked tasks
 - Cluster by scope_paths
 Output: task_signals
 
-### 1f. Heimdall Perception
+### 1c. Heimdall Perception
 - **Health snapshots**: `Bash: ls -t {project_path}/.kenaz/health_snapshots/*_after.json 2>/dev/null | head -5`
   - Read each JSON -> extract `score`, `sub_metrics`, `delta`
-- **Health trend**: post-complete only records memory health (`post_complete_verdict: RECORDED`, never reverts). Use the `score` / `delta` series from the snapshots above to spot a declining trend; a falling score points at memory-store hygiene (stale runes, episode backlog), not at the task's code.
+- **Health trend**: post-complete only records memory health (`post_complete_verdict: RECORDED`, never reverts). Use the `score` / `delta` series from the snapshots above to spot a declining trend; a falling score is a memory-store signal, not a code signal.
 - **OptimizationProposals**: `Bash: curl -s "http://127.0.0.1:18080/api/proposals/list?projectPath={project_path}&status=pending" 2>/dev/null`
   - Each proposal becomes a finding with `source: "heimdall"` -- Huginn should refine + prioritize alongside other signals
   - Dismiss processed proposals via /ignore endpoint (permanently dismissed, no task created).
   - If no verdict yet, skip marking -- GC auto-expires Huginn-generated pending proposals after 30 days.
 Output: heimdall_signals: { health_trend, optimization_proposals[] }
 
-### 1g. Wish Perception
+### 1d. Wish Perception
 - Fetch pending wishes: `Bash: curl -s http://127.0.0.1:18080/api/wishes/list?status=pending&project_path={project_path}`
 - If pending wishes exist:
   - Mark each as picked_up via `PUT /api/wishes/{id}`
@@ -155,7 +137,7 @@ Each finding is appended as one JSON line (JSONL format, English only -- MEM-LAN
 - `ts` -- ISO8601 timestamp of this Huginn run
 - `title` -- < 80 chars, English, descriptive; no "Create task" / "Open PR" phrasing
 - `insight` -- What was observed and why it matters (1-2 sentences, English)
-- `evidence` -- `{ sources: [tool_name,...], runes: [rune_id,...], metrics: {} }`
+- `evidence` -- `{ sources: [tool_name,...], metrics: {} }`
 - `confidence` -- 0.0-1.0 from scoring step
 - `source_signals` -- array of signal categories that contributed
 - `status` -- always "unread" on write; Ansuz sets to "read" / "converted" / "dismissed"
@@ -169,18 +151,9 @@ Example line (compact, one object per line):
 
 **Rotation rule (bounded file)**: On every write, the combined array of existing + new entries is sliced to the 100 most recent entries (`.slice(-100)`) before writing back. This keeps the file bounded at <= 100 lines regardless of run frequency. File size stays under ~200 KB under normal operation. Huginn itself performs the rotation inline -- no external cron needed.
 
-## Phase 4 - Inscribe (cognitive persistence)
+## Phase 4 - Record
 
-For each accepted finding involved symbols:
-  - synapse_recall to check existing runes
-  - synapse_inscribe type=insight, confidence >= 0.7
-
-If 3+ symbols form unnamed concept: synapse_forge Sigil
-
-Rules:
-- English only (MEM-LANG-001)
-- confidence >= 0.7 (higher than standard 0.6 -- derived knowledge)
-- Do NOT inscribe every finding -- only long-term value
+Huginn is advisory-only: findings go to the advisory file (Phase 3). Durable lessons are recorded by Ansuz with `kenaz learn add`; Huginn does not write memory.
 
 ---
 
@@ -193,7 +166,7 @@ Output session report (<= 20 lines):
   Trigger:   {scheduled | milestone | manual}
   Loop Mode: {manual | auto}
   Duration:  {thinking time}
-  Sources:   synapse: OK/FAIL, hippocampus: OK/FAIL, cortex: OK/FAIL, tasks: OK
+  Sources:   code: OK/FAIL, tasks: OK/FAIL, heimdall: OK/FAIL, wishes: OK/FAIL
 
   Advisories written: {N} (file: .kenaz/specialist/huginn_advisory.jsonl)
   Drafts skipped: {N}

package/core/.collaboration/core/task-2288-followups.test.js

@@ -9,11 +9,10 @@ const { spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const cp = require('child_process');
 
 const TASKAPI = path.join(__dirname, 'task-api.js');
 const TASKJSON = path.join(__dirname, 'task-api-json.js');
-const { TaskAPI, toYAML } = require('./task-api.js');
+const { toYAML } = require('./task-api.js');
 
 const SB = fs.mkdtempSync(path.join(os.tmpdir(), 't2288_'));
 const tasksDir = path.join(SB, '.kenaz', 'tasks');
@@ -37,20 +36,6 @@ const field = (id, k) => (findCard(id).text.match(new RegExp('^' + k + ':\\s*(.*
 const mkActive = (id) => fs.writeFileSync(path.join(tasksDir, 'active', id + '_t.yaml'),
   toYAML({ id, title: 't2288 ' + id, priority: 'P2', status: 'in_progress' }));
 
-// --- spawn counting seam (same as TASK_2264) ---
-let phases = [];
-const realSpawn = cp.spawn;
-cp.spawn = function (cmd, argv, opts) {
-  const script = Array.isArray(argv) ? argv.find(a => typeof a === 'string' && a.includes('const CFG')) : null;
-  if (script) {
-    const m = script.match(/"phase":"(before|after)"/);
-    phases.push(m ? m[1] : '?');
-    return { unref() {}, on() {} };
-  }
-  return realSpawn.apply(this, arguments);
-};
-const afters = () => phases.filter(p => p === 'after').length;
-
 (async () => {
   try {
     // ---- (1) actual-hours validation (CLI, subprocess so spawn patch is irrelevant) ----
@@ -90,30 +75,10 @@ const afters = () => phases.filter(p => p === 'after').length;
       check('Z3 task-api-json emits estimated_hours 0 as 0', p2 && p2.estimated_hours === 0, JSON.stringify(p2 && p2.estimated_hours) + j2.stderr);
       check('Z4 task-api-json emits actual_hours 0 as 0', p2 && p2.actual_hours === 0, JSON.stringify(p2 && p2.actual_hours));
     }
-
-    // ---- (3) single 'after' capture ----
-    const api = new TaskAPI({ tasksDir, projectPath: SB });
-    for (const envName of ['FORMATION_HEADLESS', 'FORMATION_SCHEDULER']) {
-      const id = envName === 'FORMATION_HEADLESS' ? 'TASK_9111' : 'TASK_9112';
-      mkActive(id); phases = [];
-      process.env[envName] = '1';
-      try { await api.completeTask(id, {}); } finally { delete process.env[envName]; }
-      check(`R1 ${envName}: caller's post-complete owns 'after'; moveTask schedules none`, afters() === 0, JSON.stringify(phases));
-    }
-    mkActive('TASK_9113'); phases = [];
-    process.env.FORMATION_HEADLESS = '1';
-    try { await api.completeTask('TASK_9113', { skipPostComplete: true }); } finally { delete process.env.FORMATION_HEADLESS; }
-    check('R2 control: headless + skipPostComplete (nobody else measures) keeps exactly 1 capture', afters() === 1, JSON.stringify(phases));
-    mkActive('TASK_9114'); phases = [];
-    await api.moveTask('TASK_9114', 'done');
-    check('R3 control: bare move done captures exactly once', afters() === 1, JSON.stringify(phases));
-    mkActive('TASK_9115'); phases = [];
-    await api.completeTask('TASK_9115', { dryRun: true, skipGit: true, skipArchive: true });
-    check('R4 control: in-process complete (TASK_2264) still schedules none', afters() === 0, JSON.stringify(phases));
+    // (3) the single 'after' memory-health capture checks were removed with the capture itself (TASK_2411)
   } catch (e) {
     check('no exception', false, e && e.stack);
   } finally {
-    cp.spawn = realSpawn;
     try { fs.rmSync(SB, { recursive: true, force: true }); } catch { /* best effort */ }
   }
   console.log(`\n${pass} passed, ${fail} failed`);

package/core/.collaboration/core/task-2421-replica.test.js

@@ -0,0 +1,229 @@
+#!/usr/bin/env node
+/**
+ * TASK_2421 -- shared-room card replicas, unknown-id lookup, import, alias,
+ * local_fallback warning. Uses a local stub relay (never the real relay) and
+ * temp project dirs. YGGDRASIL_PUBLISHABLE_KEY is set so ~/.kenaz is never read.
+ */
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const http = require('http');
+const { execFile } = require('child_process');
+const { TaskAPI } = require('./task-api.js');
+
+process.env.YGGDRASIL_PUBLISHABLE_KEY = 'test-key';
+const CLI = path.join(__dirname, 'task-api.js');
+
+function startRelay({ failAllocate = false } = {}) {
+  const state = { rows: new Map(), nextId: 9000, posts: [], patches: [], authSeen: [] };
+  const server = http.createServer((req, res) => {
+    let body = '';
+    req.on('data', (c) => { body += c; });
+    req.on('end', () => {
+      state.authSeen.push(req.headers.authorization);
+      const url = new URL(req.url, 'http://x');
+      const json = (code, obj) => { res.writeHead(code, { 'Content-Type': 'application/json' }); res.end(JSON.stringify(obj)); };
+      if (req.method === 'POST' && url.pathname === '/api/tasks/allocate-ids') {
+        if (failAllocate) return json(500, { error: 'down' });
+        const start = state.nextId; state.nextId += 20;
+        return json(200, { start, end: start + 19 });
+      }
+      if (req.method === 'POST' && url.pathname === '/api/tasks') {
+        const b = JSON.parse(body); state.posts.push(b);
+        state.rows.set(b.task_id, { ...b, claimed_by: null, assigned_to: b.assigned_to || null });
+        return json(200, state.rows.get(b.task_id));
+      }
+      if (req.method === 'PATCH' && url.pathname.startsWith('/api/tasks/')) {
+        const id = decodeURIComponent(url.pathname.split('/').pop());
+        const b = JSON.parse(body); state.patches.push({ id, ...b });
+        const row = state.rows.get(id);
+        if (!row) return json(409, { error: 'conflict' });
+        for (const k of ['status', 'title', 'description', 'priority', 'full_yaml']) if (b[k] != null) row[k] = b[k];
+        return json(200, row);
+      }
+      if (req.method === 'GET' && url.pathname === '/api/tasks') {
+        const wanted = (url.searchParams.get('status') || 'pool').split(',');
+        return json(200, [...state.rows.values()].filter(r => wanted.includes(r.status)));
+      }
+      json(404, {});
+    });
+  });
+  return new Promise((resolve) => server.listen(0, '127.0.0.1', () => {
+    resolve({ state, server, url: `ws://127.0.0.1:${server.address().port}` });
+  }));
+}
+
+function mkProject(yamlText) {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'task2421-'));
+  fs.mkdirSync(path.join(root, '.kenaz', 'tasks'), { recursive: true });
+  if (yamlText) fs.writeFileSync(path.join(root, '.kenaz', 'yggdrasil.yaml'), yamlText);
+  return { root, api: new TaskAPI({ projectPath: root, tasksDir: path.join(root, '.kenaz', 'tasks') }) };
+}
+
+const cfg = (url, extra = '') => `enabled: true\nrelay_url: "${url}"\nyggdrasil_project: room\nnode_name: node-A\n${extra}`;
+const card = (extra = {}) => ({ title: 'Replica me', description: 'desc', priority: 'P1', requirements: ['r1'], acceptance_criteria: ['a1'], force: true, ...extra });
+
+function cli(root, args) {
+  return new Promise((resolve) => {
+    execFile(process.execPath, [CLI, '--project-path', root, ...args], { env: process.env, timeout: 30000 },
+      (err, stdout, stderr) => resolve({ code: err ? (err.code || 1) : 0, stdout, stderr }));
+  });
+}
+
+const tests = [];
+const test = (n, f) => tests.push([n, f]);
+
+test('shared room: create publishes a non-pool read-only replica', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(cfg(relay.url));
+  const t = await api.createTask(card({ alias: '791-17' }));
+  assert.strictEqual(relay.state.posts.length, 1);
+  const p = relay.state.posts[0];
+  assert.strictEqual(p.task_id, t.id);
+  assert.strictEqual(p.status, 'assigned', 'must not be claimable pool work');
+  assert.ok(!p.assigned_to, 'no assigned_to so creator inbox (pool_pull) stays clean');
+  assert.strictEqual(p.created_by, 'node-A');
+  assert.ok(/replica: true/.test(p.full_yaml) && /791-17/.test(p.full_yaml) && /origin_node: node-A/.test(p.full_yaml));
+  assert.ok(relay.state.authSeen.every(a => a === 'Bearer test-key'));
+  assert.strictEqual(t.replica_published, true);
+  relay.server.close();
+});
+
+test('opted out (share_cards: false) -> no replica; ids still from relay', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(cfg(relay.url, 'share_cards: false\n'));
+  const t = await api.createTask(card());
+  assert.strictEqual(relay.state.posts.length, 0);
+  assert.ok(/^TASK_9\d{3}$/.test(t.id));
+  relay.server.close();
+});
+
+test('not a shared room (no yggdrasil config) -> no relay traffic', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(null);
+  await api.createTask(card());
+  assert.strictEqual(relay.state.posts.length, 0);
+  relay.server.close();
+});
+
+test('relay down: local create still succeeds with one replica warning', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(cfg(relay.url));
+  const first = await api.createTask(card()); // gets a lease while relay is up
+  await new Promise(r => relay.server.close(r));
+  const warns = [];
+  const orig = console.warn; console.warn = (...a) => warns.push(a.join(' '));
+  let t;
+  try { t = await api.createTask(card({ title: 'Second' })); } finally { console.warn = orig; }
+  assert.ok(t && t.id && t.id !== first.id);
+  assert.ok(fs.existsSync(t._file_path), 'local card written');
+  assert.strictEqual(t.replica_published, false);
+  assert.strictEqual(warns.filter(w => /replica not published/.test(w)).length, 1);
+});
+
+test('local_fallback in a shared room warns loudly (stderr + create output)', async () => {
+  const { api, root } = mkProject(cfg('ws://127.0.0.1:1')); // unreachable relay, no lease
+  const r = await cli(root, ['create', '--title', 'Fallback', '--force']);
+  assert.strictEqual(r.code, 0, r.stderr);
+  assert.ok(/ID COLLISION RISK/.test(r.stderr), 'stderr warning');
+  assert.ok(/⚠️.*locally because the relay is unreachable/.test(r.stdout), 'create output warning');
+  assert.ok(api);
+});
+
+test('solo project local id allocation prints no collision warning', async () => {
+  const { root } = mkProject(null);
+  const r = await cli(root, ['create', '--title', 'Solo', '--force']);
+  assert.strictEqual(r.code, 0, r.stderr);
+  assert.ok(!/COLLISION/.test(r.stderr + r.stdout));
+});
+
+test('get unknown id shows replica with owner node; mutations explain, create no local file', async () => {
+  const relay = await startRelay();
+  const a = mkProject(cfg(relay.url));
+  const t = await a.api.createTask(card());
+  // node B: same room, empty local store
+  const b = mkProject(cfg(relay.url).replace('node-A', 'node-B'));
+  const g = await cli(b.root, ['get', t.id]);
+  assert.strictEqual(g.code, 0, g.stderr);
+  const out = JSON.parse(g.stdout);
+  assert.strictEqual(out.read_only_replica, true);
+  assert.strictEqual(out.title, 'Replica me');
+  assert.ok(/read-only replica; card lives on node node-A/.test(out.replica_notice));
+  assert.ok(/task-api\.js pull /.test(out.replica_notice));
+  for (const args of [['move', t.id, 'active'], ['update', t.id, '--title', 'x'], ['complete', t.id]]) {
+    const r = await cli(b.root, args);
+    assert.notStrictEqual(r.code, 0, args.join(' '));
+    assert.ok(/read-only replica; card lives on node node-A/.test(r.stderr + r.stdout), args.join(' ') + ': ' + r.stderr);
+  }
+  const files = fs.readdirSync(path.join(b.root, '.kenaz', 'tasks'), { recursive: true }).filter(f => /TASK_/.test(String(f)));
+  assert.strictEqual(files.length, 0, 'no broken local file: ' + files.join(','));
+  // truly unknown id still says not found
+  const miss = await cli(b.root, ['get', 'TASK_424242']);
+  assert.notStrictEqual(miss.code, 0);
+  assert.ok(/任務不存在/.test(miss.stderr));
+  relay.server.close();
+});
+
+test('status changes on the owner keep the replica current', async () => {
+  const relay = await startRelay();
+  const { api } = mkProject(cfg(relay.url));
+  const t = await api.createTask(card());
+  await api.moveTask(t.id, 'active');
+  assert.strictEqual(relay.state.rows.get(t.id).status, 'in_progress');
+  await api.updateTask(t.id, { title: 'Renamed' });
+  assert.strictEqual(relay.state.rows.get(t.id).title, 'Renamed');
+  relay.server.close();
+});
+
+test('pull imports a local copy marked with origin node', async () => {
+  const relay = await startRelay();
+  const a = mkProject(cfg(relay.url));
+  const t = await a.api.createTask(card({ alias: '791-18' }));
+  const b = mkProject(cfg(relay.url).replace('node-A', 'node-B'));
+  const r = await cli(b.root, ['pull', t.id]);
+  assert.strictEqual(r.code, 0, r.stderr);
+  const local = await b.api.getTask(t.id);
+  assert.ok(local, 'local copy exists');
+  assert.strictEqual(local.origin_node, 'node-A');
+  assert.strictEqual(local.title, 'Replica me');
+  assert.strictEqual(local.alias, '791-18');
+  const again = await cli(b.root, ['pull', t.id]);
+  assert.notStrictEqual(again.code, 0);
+  relay.server.close();
+});
+
+test('alias: create/update/get/search resolve to the TASK id', async () => {
+  const { api, root } = mkProject(null);
+  const t = await api.createTask(card({ alias: '791-17' }));
+  const g = await cli(root, ['get', '791-17']);
+  assert.strictEqual(g.code, 0, g.stderr);
+  assert.strictEqual(JSON.parse(g.stdout).id, t.id);
+  const s = await cli(root, ['search', '791-17']);
+  assert.ok(s.stdout.includes(t.id));
+  const u = await cli(root, ['update', t.id, '--alias', '791-99']);
+  assert.strictEqual(u.code, 0, u.stderr);
+  const g2 = await cli(root, ['get', '791-99']);
+  assert.strictEqual(JSON.parse(g2.stdout).id, t.id);
+});
+
+test('get by alias of a replica that exists only on the relay', async () => {
+  const relay = await startRelay();
+  const a = mkProject(cfg(relay.url));
+  const t = await a.api.createTask(card({ alias: '791-20' }));
+  const b = mkProject(cfg(relay.url).replace('node-A', 'node-B'));
+  const g = await cli(b.root, ['get', '791-20']);
+  assert.strictEqual(g.code, 0, g.stderr);
+  assert.strictEqual(JSON.parse(g.stdout).id, t.id);
+  relay.server.close();
+});
+
+(async () => {
+  let failed = 0;
+  for (const [name, fn] of tests) {
+    try { await fn(); console.log(`  ok   ${name}`); }
+    catch (e) { failed++; console.log(`  FAIL ${name}\n       ${e && e.stack || e}`); }
+  }
+  console.log(`\n${tests.length - failed}/${tests.length} passed`);
+  process.exit(failed ? 1 : 0);
+})();