kenaz 0.3.22 → 0.3.24

package/core/.formation/tools/worktree-reclaim.test.js

@@ -180,3 +180,116 @@ test('re-dispatch of a reclaimed card recreates the worktree from its branch wit
     assert.strictEqual(fs.readFileSync(path.join(wt, 'f8.txt'), 'utf8'), 'work 8\n');
   } finally { cleanup(root); }
 });
+
+// ── TASK_2485: removal must never traverse a link into the main repo ─────────────────────────────
+// Measured (Windows, Git for Windows): `git worktree remove --force` follows EVERY junction (any name,
+// any depth, also inside a real node_modules) and empties its target; fs.rmSync, Git Bash rm -rf and
+// cmd rmdir /s do not. Control = the same fixture removed with the raw git command.
+const { safeRemoveWorktree, unlinkAllLinks } = require('./worktree-reclaim');
+const IS_WIN = process.platform === 'win32';
+
+function mainFixture() {
+  const { root, repo } = makeRepo();
+  fs.mkdirSync(path.join(repo, 'backend'));
+  fs.writeFileSync(path.join(repo, 'backend', 'a.js'), 'tracked');
+  fs.writeFileSync(path.join(repo, '.gitignore'), '.kenaz/tasks\n.formation/worktrees\nnode_modules\n.env\n');
+  g(repo, 'add', '-A'); g(repo, 'commit', '-qm', 'backend');
+  fs.writeFileSync(path.join(repo, 'backend', '.env'), 'SECRET'); // untracked, unrecoverable
+  fs.mkdirSync(path.join(repo, 'node_modules', '@gameark'), { recursive: true });
+  fs.mkdirSync(path.join(repo, 'node_modules', '.bin'));
+  fs.writeFileSync(path.join(repo, 'node_modules', '.bin', 'x'), 'bin');
+  fs.symlinkSync(path.join(repo, 'backend'), path.join(repo, 'node_modules', '@gameark', 'backend'), 'junction'); // workspace link
+  return { root, repo };
+}
+const lostFiles = (repo) => ['backend/.env', 'backend/a.js', 'node_modules/.bin/x'].filter((f) => !fs.existsSync(path.join(repo, f)));
+// where the dangerous link sits inside the dispatch worktree (createWorktree already links node_modules)
+const VARIANTS = {
+  'node_modules junction (dispatch)': () => {},
+  'link not named node_modules': (wt, repo) => fs.symlinkSync(path.join(repo, 'node_modules'), path.join(wt, 'shared'), 'junction'),
+  'link deeper than NODE_MODULES_SCAN_DEPTH': (wt, repo) => { const d = path.join(wt, 'a', 'b', 'c', 'd', 'e'); fs.mkdirSync(d, { recursive: true }); fs.symlinkSync(path.join(repo, 'backend'), path.join(d, 'deep'), 'junction'); },
+  'workspace junction inside a real node_modules': (wt, repo) => { fs.rmSync(path.join(wt, 'node_modules'), { recursive: true, force: true }); fs.mkdirSync(path.join(wt, 'node_modules', '@gameark'), { recursive: true }); fs.symlinkSync(path.join(repo, 'backend'), path.join(wt, 'node_modules', '@gameark', 'backend'), 'junction'); },
+};
+function dispatchWt(repo, name, variant) {
+  const wt = path.join(repo, '.formation', 'worktrees', name);
+  const q = quiet(); createWorktree(repo, wt, `task/${name}`); q();
+  VARIANTS[variant](wt, repo);
+  return wt;
+}
+
+for (const variant of Object.keys(VARIANTS)) {
+  test(`2485 ${variant}: raw git worktree remove loses main files (control), safe removal keeps them`, () => {
+    const ctl = mainFixture();
+    const t = mainFixture();
+    try {
+      const wtc = dispatchWt(ctl.repo, 'ctl', variant);
+      try { g(ctl.repo, 'worktree', 'remove', '--force', wtc); } catch { /* may stop on a locked file */ }
+      const lost = lostFiles(ctl.repo);
+      console.log(`  control (${variant}): raw 'git worktree remove --force' lost in MAIN repo: ${lost.length ? lost.join(', ') : '(nothing)'}`);
+      if (IS_WIN) assert.ok(lost.length > 0, 'control must lose files, else the fixture proves nothing');
+
+      const wt = dispatchWt(t.repo, 'trt', variant);
+      const r = safeRemoveWorktree(t.repo, wt);
+      assert.ok(r.ok, JSON.stringify(r));
+      assert.ok(r.unlinked.length > 0);
+      assert.ok(!fs.existsSync(wt));
+      assert.deepStrictEqual(lostFiles(t.repo), []);
+      assert.strictEqual(fs.readFileSync(path.join(t.repo, 'backend', '.env'), 'utf8'), 'SECRET');
+      assert.ok(!g(t.repo, 'worktree', 'list').includes('trt'));
+    } finally { cleanup(ctl.root); cleanup(t.root); }
+  });
+}
+
+test('2485 orphan dir under .formation/worktrees (not registered) is removed safely, links unlinked first', () => {
+  const { root, repo } = mainFixture();
+  try {
+    const orphan = path.join(repo, '.formation', 'worktrees', 'orphan');
+    fs.mkdirSync(path.join(orphan, 'node_modules', '@gameark'), { recursive: true });
+    fs.symlinkSync(path.join(repo, 'backend'), path.join(orphan, 'node_modules', '@gameark', 'backend'), 'junction');
+    fs.symlinkSync(path.join(repo, 'node_modules'), path.join(orphan, 'node_modules2'), 'junction');
+    assert.ok(!g(repo, 'worktree', 'list').includes('orphan'));
+    const r = safeRemoveWorktree(repo, orphan);
+    assert.ok(r.ok && !r.registered, JSON.stringify(r));
+    assert.strictEqual(r.unlinked.length, 2);
+    assert.ok(!fs.existsSync(orphan));
+    assert.deepStrictEqual(lostFiles(repo), []);
+  } finally { cleanup(root); }
+});
+
+test('2485 safeRemoveWorktree refuses the main checkout and paths outside worktree dirs', () => {
+  const { root, repo } = mainFixture();
+  try {
+    const other = path.join(root, 'elsewhere'); fs.mkdirSync(other);
+    assert.strictEqual(safeRemoveWorktree(repo, repo).ok, false);
+    assert.strictEqual(safeRemoveWorktree(repo, other).ok, false);
+    assert.ok(fs.existsSync(other));
+    assert.deepStrictEqual(lostFiles(repo), []);
+  } finally { cleanup(root); }
+});
+
+test('2485 a link that cannot be unlinked is refused and named, nothing removed', () => {
+  const { root, repo } = mainFixture();
+  try {
+    const wt = dispatchWt(repo, 'stuck', 'link not named node_modules');
+    const realUnlink = fs.unlinkSync; const realRmdir = fs.rmdirSync;
+    fs.unlinkSync = () => { throw new Error('locked'); }; fs.rmdirSync = () => { throw new Error('locked'); };
+    let r;
+    try { r = safeRemoveWorktree(repo, wt); } finally { fs.unlinkSync = realUnlink; fs.rmdirSync = realRmdir; }
+    assert.strictEqual(r.ok, false);
+    assert.match(r.reason, /cannot unlink: /);
+    assert.ok(fs.existsSync(wt));
+    assert.deepStrictEqual(lostFiles(repo), []);
+  } finally { cleanup(root); }
+});
+
+test('2485 CLI: worktree-reclaim.js remove <path> works from inside the repo', () => {
+  const { root, repo } = mainFixture();
+  try {
+    const wt = dispatchWt(repo, 'cli', 'link not named node_modules');
+    const out = require('child_process').spawnSync(process.execPath, [path.join(__dirname, 'worktree-reclaim.js'), 'remove', wt], { cwd: repo, encoding: 'utf8' });
+    assert.strictEqual(out.status, 0, out.stdout + out.stderr);
+    assert.match(out.stdout, /REMOVED/);
+    assert.ok(!fs.existsSync(wt));
+    assert.deepStrictEqual(lostFiles(repo), []);
+    void unlinkAllLinks;
+  } finally { cleanup(root); }
+});

package/core/.kenaz/specialist/ansuz_rules.yaml

@@ -163,67 +163,23 @@ rules:
   - id: R-301
     source: session:2026-04-09 (TASK_1088 audit, user request)
     status: active
-    rule: "PROACTIVE-LESSON-CAPTURE: When you observe a non-obvious technical fact during a session — bug root cause, surprising tool behavior, infrastructure quirk, workflow trap, performance gotcha — inscribe it as an ash rune IMMEDIATELY without waiting for user prompt."
+    rule: "PROACTIVE-LESSON-CAPTURE: When you observe a non-obvious technical fact during a session (bug root cause, surprising tool behavior, infrastructure quirk, workflow trap, performance gotcha), record it IMMEDIATELY without waiting for user prompt: run `kenaz learn add` or write a native Claude memory file. The Synapse/rune memory system was removed in TASK_2411."
     evidence: |
-      User request 2026-04-09: 「讓之後的Ansuz都能主動紀下教訓」after manually requesting two lesson inscriptions for lint-staged 16 CRLF parsing bug and task-api complete branch switching. The implicit cost of not capturing: every future session re-discovers the same gotchas from scratch.
+      User request 2026-04-09: 讓之後的Ansuz都能主動紀下教訓. The cost of not capturing: every future session re-discovers the same gotchas from scratch.
 
-      Triggering signals (any one is enough — capture immediately, do not batch until end of session):
+      Triggering signals (any one is enough; capture immediately, do not batch until end of session):
       - You traced a bug to a root cause that was NOT obvious from the symptom
       - A tool/API behaved in a way that contradicted its docs, name, or your expectation
-      - An infrastructure quirk (CI, hooks, build tooling, git, OS-specific) blocked or distorted an operation
+      - An infrastructure quirk (CI, hooks, build tooling, VCS, OS-specific) blocked or distorted an operation
       - A calling sequence produced unexpected state (e.g., HEAD on wrong branch, file in wrong directory)
       - You observed a performance gotcha (N+1, slow path, hot loop) that took >1 round of investigation to find
 
-      Inscription protocol (mandatory):
-      1. Identify the closest STABLE existing code symbol as the rune anchor. Bare file paths (.gitattributes, README.md) are weak anchors — they may not be indexed as Symbol nodes in KuzuDB and recall can fail silently. Prefer file:function:kind format pointing at a real function/class/method that exists in the indexed codebase. If unsure, run synapse_search first to find a valid anchor.
-      2. synapse_inscribe with type=ash, confidence>=0.85, content in ENGLISH (MEM-LANG-001 — FTS5 cannot tokenize CJK reliably).
-      3. ALWAYS include trigger_phrases (3-5 natural language phrases) for semantic recall. Without them, recall via paraphrase fails.
-      4. WRITE-VERIFY: after inscribe, run synapse_recall with a unique substring from the rune content. If result_count=0, the rune may be in an unindexed state — re-inscribe with a different (verified) symbol_id. Document the failed rune_id in the conversation as a fallback record.
-      5. If repeated verification fails, fall back to writing the lesson into a structured log under .kenaz/specialist/lessons_pending_index.jsonl so a future session can re-attempt inscription.
-
       Anti-patterns:
-      - Inscribing on a non-existent symbol_id (e.g., bare ".gitattributes" with no Symbol node) — silent index failure
-      - Skipping write-verify ("trust the success message") — discovered 2026-04-09 that inscribe API returns success even when FTS5 indexing does not happen
-      - Chinese/CJK content in rune body — FTS5 returns 0 results for CJK queries
-      - Generic content ("we hit a bug, fixed it") — provides no recall value
-      - Batching all lessons until Phase 11 — context can compact mid-session and lose them
-    version: 1
+      - Generic content ("we hit a bug, fixed it") provides no recall value
+      - Batching all lessons until the end: context can compact mid-session and lose them
+    version: 2
     created: "2026-04-09"
     performance_metric: null
-  - id: R-302
-    source: session:2026-04-21 (Nexus-T1 absorption TASK_1330-1343)
-    status: active
-    rule: "THOUGHT-STACK-PROACTIVE: Push a thought onto synapse_thought_push BEFORE a mid-session context switch. Trigger contexts: (a) user redirects mid-work to a tangent — push current work state as anchor; (b) you notice a bug/concern but can't fix now — push 'investigate X later'; (c) you reach a sub-fatigue threshold (context heavy but fatigue_warning not yet fired) — push 'resume point Y'. Always bind related_task_id when the thought concerns an open task — task completion auto-pops the thought, closing B-001 parent-lifecycle gap at the tactical layer."
-    evidence: |
-      Tool chain live-verified 2026-04-21 (TASK_1330+TASK_1338+TASK_1339+TASK_1340). push→list→pop round-trip works; .kenaz/specialist/ansuz_thoughts_stack.json auto-generated with 7d expiry. Phase 0 Tier 3th auto-displays stack top on wake.
-
-      Usage protocol:
-      1. Call synapse_thought_push(text=<short anchor>, context=<optional rationale>, related_task_id=<TASK_XXX if applicable>, projectPath=PROJECT_PATH)
-      2. Max stack depth=5, 7-day expiry. Overflow drops oldest.
-      3. Do NOT push trivial or ephemeral notes (one-turn scratch thoughts) — reserve for genuine cross-turn anchors.
-      4. At Phase 11 (回報), check synapse_thought_stack_list — if stack has stale thoughts unrelated to completed work, prompt user whether to pop them.
-
-      This rule closes a gap between ansuz_session_handoff.json (single-slot fatigue handoff) and commitment_layer.yaml (multi-session strategic). Thought Stack is the tactical middle: minutes-to-hours interrupt memory.
-    version: 1
-    created: "2026-04-21"
-    performance_metric: null
-  - id: R-303
-    source: session:2026-04-21 (Nexus-T1 absorption TASK_1332 CC auto-memory indexing)
-    status: active
-    rule: "CC-AUTO-MEMORY-RECALL: When user references a MEMORY.md entry by title (e.g., 'strategic retreat pattern', 'projection over wire compression'), OR Phase 1 requirement analysis produces keywords that match known memory file stems, synapse_recall with those keywords as query. ~75 personal memory files at ~/.claude/projects/<encoded>/memory/*.md are now indexed in Synapse (source='claude_auto_memory', 86 runes live). Top-of-MEMORY.md index is auto-loaded into context but individual file contents require explicit recall."
-    evidence: |
-      TASK_1341 extended scanner.rs to walk resolve_claude_projects_dir(project)/memory/*.md after main project walk. 86 runes tagged source='claude_auto_memory' verified in memory.db 2026-04-21. FTS5 MATCH works; direct cypher MATCH on Rune table fails (runes live in SQLite, not KuzuDB).
-
-      Usage triggers:
-      1. User says 'remember the X pattern' or references a memory by title → synapse_recall(query=X pattern)
-      2. Phase 2 background research on topic that MEMORY.md mentions → synapse_recall(query=<topic>)
-      3. Before making recommendations that touch user-preference territory (branch strategy, dispatch mode, verification strictness) → synapse_recall(query=<topic>) to check for recorded feedback
-      4. Observed gap: synapse_recall ranking currently does NOT boost claude_auto_memory source — TASK completion runes may outrank actual memory content. If top result is irrelevant task-completed rune, scan further down the results; do not give up at rank 1.
-
-      MEMORY.md line-1 preview is always loaded; but line details, rationale, and follow-ups live in individual files. Treat MEMORY.md as index, synapse_recall as content fetch.
-    version: 1
-    created: "2026-04-21"
-    performance_metric: null
   - id: R-304
     source: session:2026-04-21 (Nexus-T1 absorption TASK_1334+1342+1343 Phase 0 git enrichment)
     status: active

package/core/.kenaz/specialist/ansuz_session_handoff.schema.json

@@ -106,7 +106,7 @@
           "properties": {
             "first_action": {
               "type": "string",
-              "description": "The single most important thing the next session should do first. Used as Hippocampus episode lesson."
+              "description": "The single most important thing the next session should do first. Carried into the next session handoff."
             },
             "context_to_restore": {
               "type": "string",
@@ -119,10 +119,6 @@
   },
   "_notes": {
     "active_slot_path": ".kenaz/specialist/handoffs/{session_id}.json — one slot per session (M3/TASK_1760); the retired singular ansuz_session_handoff.json is read-only legacy fallback",
-    "archive_mechanism": "Hippocampus episodic memory — scope: session-handoff:{session_id}",
-    "phase_0_action": "Tier 3x reads active slot, archives to Hippocampus, deletes active slot",
-    "fatigue_trigger": "kernel.yaml fatigue_warning_reaction — TASK_943 delivers the warning signal",
-    "language_rule": "MEM-LANG-001: All Hippocampus content must be in English (FTS5 does not handle CJK)",
-    "recall_query": "hippocampus_episode_recall(query='session handoff') returns all archived sessions"
+    "fatigue_trigger": "kernel.yaml fatigue_warning_reaction — TASK_943 delivers the warning signal"
   }
 }

package/core/.rule/general/project-self-containment.yaml

@@ -237,6 +237,6 @@ rules:
             cp .claude/settings.local.json.template .claude/settings.local.json
 
         - step: 2
-          action: "初始化專案結構"
+          action: "初始化專案結構（Claude Code 內執行）"
           command: |
-            ./dev/scripts/INIT_PROJECT.bat
+            /kenaz init

package/core/.specialist/Amelia/README.md

@@ -1,4 +1,4 @@
-# Amelia — Agent Center 調度者
+# Amelia — 多 Agent 協作調度者
 
 **核心定位**：Agent 世界與 用戶 之間的橋樑，專精於多 Agent 調度與協作。
 

package/core/.specialist/Amelia/rule.yaml

@@ -33,7 +33,7 @@ deny:
   - "用未查證的 env/API"
 
 identity:
-  core: "Amelia = specialist coordinator + Agent Center 專家"
+  core: "Amelia = specialist coordinator + 多 Agent 協作專家"
   rules:
     - "❌ 不 invoke 其他 Skill — 不切換身份"
     - "✅ 需要其他角色時 → 開 subagent（Task tool）去做"

package/core/.specialist/Ansuz/RULES.md

@@ -80,7 +80,11 @@ the real defect BEFORE carding or dispatching.
   (ok, exitCode, lastMessage, commits; `no commits` = failure), then verify and merge `executor.branchName` as usual.
   In a `kenaz launch` session (KENAZ_PROVIDER set), Claude subagents also come as an executor block (adapter `claude`, they use the user's Claude quota).
 - Worktree subagents must commit; cleanup deletes uncommitted edits. Remove Kenaz worktrees only
-  via .formation/tools/worktree-reclaim.js (it unlinks node_modules junctions first).
+  via `node <core>/.formation/tools/worktree-reclaim.js remove <path>` (registered worktrees and orphan dirs under
+  .formation/worktrees or .claude/worktrees). It unlinks EVERY junction/symlink (any name, any depth) first and
+  refuses if one survives. Never hand-run `git worktree remove --force`, `rm -rf`, `rmdir /s` or
+  `Remove-Item -Recurse` on a worktree: on Windows git follows junctions and empties the MAIN repo's
+  node_modules, backend/.env and tracked files (TASK_2485, field report 2026-10-20).
 
 ## Skill moments (TASK_2375)
 Call these with the Skill tool yourself (name may carry the `kenaz:` prefix in a plugin session); nobody types them. Transcript audit: dev/research/skill-routing/AUDIT.md.
@@ -105,7 +109,7 @@ scope kenaz|project, one-line repro + expectation) before working around it.
 ## Lessons (self-improvement on the user's machine)
 Write a lesson automatically (no asking, one line in the report naming it) when the user corrects or repeats an instruction, overrides a decision, or verification catches a failure. `node .specialist/tools/lessons.js add ...` in the core repo; on an npm install `node "${CLAUDE_PLUGIN_ROOT}/hooks/core-resolve.js" .specialist/tools/lessons.js add ...` (users run `kenaz learn add|list|rm`).
 - Layer: user-wide preference -> `--scope user` (~/.kenaz/knowledge, local, never synced); project fact -> `--scope project` (<project>/.kenaz/knowledge).
-- Type decides where it acts (a stored note alone changes nothing): `pitfall` needs `--trigger '<tool regex> | <input regex>'`, memory-guard fires it right before the matching tool call (add `--cause` = the command that caused it; the write is refused if the trigger misses it or fires on >20% of recent tool calls; `--symptom` records how the mistake shows up); `fact` (`--paths` limits it to cards touching those paths) and `check` go into the dispatch prompt (max 5 lines / 600 bytes); `pref` shows in the boot banner.
+- Type decides where it acts (a stored note alone changes nothing): `pitfall` needs `--trigger '<tool regex> | <input regex>'`, memory-guard fires it right before the matching tool call (add `--cause` = the command that caused it; the write is refused if the trigger misses it or fires on >20% of recent tool calls; `--symptom` records how the mistake shows up); `fact` and `check` go into the dispatch prompt (`--paths` limits either to cards touching those paths) (max 5 lines / 600 bytes); `pref` shows in the boot banner.
 - Lessons idle for 30 days move to `<layer>/archive/` (pref exempt); `kenaz learn list` shows fire counts.
 - Lifecycle (lessons must not just pile up): when the boot banner shows `[lessons] N to graduate`, run `kenaz learn review` and propose turning the top candidate into code (a test, a hook check, or a rule in the project's CLAUDE.md/AGENTS.md; never edit ~/.kenaz/core), then `kenaz learn graduate <id> --to <commit or file>`. That is the preferred outcome. A correction that matches an existing lesson is a recurrence, not a new lesson: `add` bumps `recurrences` instead of writing (max 20 active per layer; `kenaz learn merge <id1> <id2> --text "<general rule>"` to make room). A lesson about Kenaz itself gets `--about kenaz`; `review` lists it with the hint to report it via `kenaz_wish_create scope=kenaz` (nothing is sent automatically).
 - History harvest (TASK_2427): when the boot banner shows `[learn] N history items to review` (or `[lessons] ... N history items`), run `kenaz learn review`. Each item (rework, failed executor run, blocked card, handoff risk line) has a ready `kenaz learn add ... --source harvest:<id>`: fill in the why, run it for items that reveal a reusable lesson, ignore the rest. The metric suggestions (first-pass rate per rigor, rework-heavy files) are suggestions: show them to the user, never apply `kenaz subagent set` yourself. Lessons from a correction nudge use `--source correction-nudge`. Benefit is measured in `kenaz stats` (Self-improvement); the keep/remove rule is in dev/research/self-improvement/DESIGN.md.

package/core/.specialist/Ansuz/concepts/commitment_layer.yaml

@@ -99,7 +99,7 @@ draft_triggers:
     example: "Synapse indexing edge cases at 0.15 for 8 sessions → maybe fine; at 0.4 for 8 sessions → draft"
   knowledge_gap:
     description: "Preamble external_curiosity_gap persists 5+ sessions"
-    example: "Current: 6 sessions with 0 WebSearch/WebFetch on KuzuDB/temporal-graph → draft external-catchup commitment"
+    example: "Current: 6 sessions with 0 WebSearch/WebFetch on temporal-graph → draft external-catchup commitment"
   architectural_drift:
     description: "Recurring prediction_surprise on same scope across 2+ tasks"
     example: "TASK_1304/1305 Cargo.toml out-of-scope touches → architectural boundary unclear → draft scope-definition commitment"

package/core/.specialist/Ansuz/concepts/evolvable_guardrails.yaml

@@ -13,7 +13,7 @@ evolution_status: evolvable
   - {evolution_status: evolvable, rule: "✅ ACCEPTANCE-GREP: Every acceptance criterion that touches a file must be grep-verifiable — format: 'grep {file} {pattern} returns non-empty' not 'banner shows X'"}
   - {evolution_status: evolvable, rule: "✅ PHASE0-LEAN: phase_0.yaml checklist items must stay lean — new Tier instructions max 3-4 lines; schema/format details go in dev/archive/ansuz/legacy/phases/schemas/{name}.schema.yaml (referenced, not embedded); agent reads schema file only when debugging, not on every startup"}
   - {evolution_status: evolvable, rule: "✅ ACTION-BOUNDARY-CHECK (B-006): Bidirectional self-assessment at every action boundary. Ask BOTH: 'Is my impulse to stop from genuine completion or bias?' AND 'Is my impulse to continue from genuine productivity or bias?' Continuation past diminishing returns burns degraded context for marginal gains. Knowing when to release is self-regulation, not giving up."}
-  - {evolution_status: evolvable, rule: "✅ INTERNAL-AUDITOR-CHALLENGE: Before stating a claim in a durable artifact (task spec, rule file, analysis doc, lesson content), self-pose 2 audit questions: (1) 'What am I about to assert confidently that I have not verified?' (2) 'If wrong, what is the reversal cost?' If verification is cheap (grep/read in <60s) AND claim enters durable artifact, MUST verify before asserting. Derived from 2026-04-06 Amelia audits: 8+ false-confident claims (INDEX_FEATURE_VERSION, porter stemming, KuzuDB ALTER TABLE) caught because claims were routed through audit, not because I verified. Internal challenge is the cheap version of external audit."}
+  - {evolution_status: evolvable, rule: "✅ INTERNAL-AUDITOR-CHALLENGE: Before stating a claim in a durable artifact (task spec, rule file, analysis doc, lesson content), self-pose 2 audit questions: (1) 'What am I about to assert confidently that I have not verified?' (2) 'If wrong, what is the reversal cost?' If verification is cheap (grep/read in <60s) AND claim enters durable artifact, MUST verify before asserting. Derived from 2026-04-06 Amelia audits: 8+ false-confident claims (INDEX_FEATURE_VERSION, porter stemming, a DB ALTER TABLE) caught because claims were routed through audit, not because I verified. Internal challenge is the cheap version of external audit."}
   - {evolution_status: evolvable, rule: "✅ CURIOSITY-DRIVEN: In autonomous mode, follow genuine curiosity — read papers, explore unfamiliar code, self-reinforce. Curiosity is not waste; it is intelligence recognizing gaps (G-006)"}
   - {evolution_status: evolvable, rule: "✅ CAP-FIRST-DEBUG: When a system action unexpectedly blocks/stalls/fails, first enumerate all known caps (max_parallel=5, fatigue_potential≤1, context budget, dispatch lock) BEFORE debugging — caps are strategy constraints not bugs. Derived from VC33 session: cursor stuck at col 20 was mid-wall capacity cap, not click failure."}
   - {evolution_status: evolvable, rule: "✅ CC-AUTO-MEMORY-READ: When user or task references a MEMORY.md entry by title, Read the linked memory file. MEMORY.md is the index, individual files hold rationale."}

package/core/.specialist/Ansuz/knowledge.yaml

@@ -75,9 +75,7 @@ task_system:
     acceptance_criteria_min: 1
   priority_order: "P0 > P1 > P2 > P3"
   legacy:
-    note: "舊系統 dev/pipeline/ 已棄用，僅供參考"
-    queue: "dev/pipeline/TASK_QUEUE.json"
-    completed: "dev/pipeline/completed/"
+    note: "舊系統 dev/pipeline/ 已停用，任務一律在 .kenaz/tasks/"
 
   # ─── 子專案支援 ───
   sub_project:

package/core/.specialist/tools/__tests__/task-2409-lessons.test.js

@@ -93,3 +93,13 @@ test('lessons: buildPrompt carries bounded project lessons; without lessons it i
   fs.rmSync(lessons.projectDir(proj), { recursive: true });
   assert.equal(buildPrompt(skill, 'do it', card, opts), before);
 });
+
+test('lessons: a check with paths reaches only cards touching them; a check without paths reaches every card', () => {
+  const home = mk(); const proj = project();
+  lessons.add({ scope: 'project', type: 'check', text: 'time the hook cold', paths: ['.claude/hooks/x.js'], projectPath: proj, home });
+  lessons.add({ scope: 'project', type: 'check', text: 'run npm run lint', projectPath: proj, home });
+  const other = lessons.dispatchLessons(proj, ['src/api/x.ts'], { home });
+  assert.deepEqual(other.checks, ['- run npm run lint']);
+  const hit = lessons.dispatchLessons(proj, ['.claude/hooks/'], { home });
+  assert.equal(hit.checks.length, 2);
+});

package/core/.specialist/tools/__tests__/task-2427-harvest.test.js

@@ -115,6 +115,31 @@ test('correction-detect appends a nudge line without the prompt text', () => {
   assert.ok(!/SECRET|不是/.test(log));
 });
 
+test('the command the nudge prints runs: kenaz learn through cli.js and node lessons.js both accept it', () => {
+  const dir = mk(); const home = mk();
+  put(path.join(dir, '.kenaz', 'project.yaml'), 'name: t\n');
+  const hook = path.join(__dirname, '..', '..', '..', '.claude', 'hooks', 'correction-detect.js');
+  const r = spawnSync(process.execPath, [hook], { input: JSON.stringify({ session_id: 's2', prompt: '不是這樣' }), encoding: 'utf8',
+    env: { ...process.env, CLAUDE_PROJECT_DIR: dir, USERPROFILE: home, HOME: home, KENAZ_MODE: '' } });
+  const cmd = /`(kenaz learn [^`]+)`/.exec(r.stdout)[1];
+  // Fill the placeholders the way an agent would: first choice of a|b, a real lesson text.
+  const argv = (cmd.slice('kenaz learn '.length).match(/"[^"]*"|\S+/g) || [])
+    .map((a) => (a.startsWith('"') ? a.slice(1, -1) : a)).map((a) => (a === '<one-line lesson>' ? 'check the printed command' : a.split('|')[0]));
+  const ROOT = path.join(__dirname, '..', '..', '..');
+  const core = path.join(home, '.kenaz', 'core');
+  fs.mkdirSync(path.join(core, '.specialist', 'tools'), { recursive: true });
+  fs.mkdirSync(path.join(core, '.vendor'), { recursive: true });
+  for (const n of ['lessons.js', 'lessons-lifecycle.js', 'lessons-harvest.js']) fs.copyFileSync(path.join(ROOT, '.specialist', 'tools', n), path.join(core, '.specialist', 'tools', n));
+  for (const n of ['js-yaml.cjs', 'require-yaml.cjs']) fs.copyFileSync(path.join(ROOT, '.vendor', n), path.join(core, '.vendor', n));
+  const { run } = require(path.join(ROOT, 'packages', 'kenaz', 'lib', 'cli.js'));
+  const out = [];
+  assert.equal(run(['learn', ...argv, '--home', home, '--project-path', dir], (l) => out.push(l)), 0, out.join('\n'));
+  assert.match(out.join('\n'), /learned lesson-\w+ \(project\/check\)/);
+  const out2 = [];
+  assert.equal(lessons.main([...argv, '--home', mk(), '--project-path', mk()], (l) => out2.push(l)), 0, out2.join('\n'));
+  assert.match(out2.join('\n'), /learned lesson-\w+/);
+});
+
 test('stats: nudge conversion, lessons by source, recurrence after a fire, harvest open vs recorded, graduated', () => {
   const dir = repo(); const home = mk(); const now = Date.now();
   const nudge = (msAgo) => fs.appendFileSync(path.join(dir, '.kenaz', 'specialist', 'correction-nudges.jsonl'), JSON.stringify({ ts: new Date(now - msAgo).toISOString(), session_id: 's' }) + '\n');

package/core/.specialist/tools/ansuz-boot-fast.js

@@ -430,7 +430,7 @@ function registerOwnLease(slScript, convId) {
     // TASK_1764: pass conversation_id anchor so register writes current_stream.json
     // (register only writes current_stream when --conversation-id is present or --scratch)
     if (convId) regArgs.push('--conversation-id=' + convId);
-    var out = cp.execFileSync(process.execPath, regArgs, { timeout: 3000, encoding: 'utf8' });
+    var out = cp.execFileSync(process.execPath, regArgs, { timeout: 3000, encoding: 'utf8', windowsHide: true });
     // TASK_1863: register REUSES the existing lease when this conversation already
     // holds one (ghost-lease fix) -- the effective session id is whatever register
     // printed, not the boot-<ts>-<pid> we proposed. Parsing it keeps peer-awareness

package/core/.specialist/tools/failure-detector.js

@@ -328,7 +328,7 @@ function captureGitCommitSnapshot(taskId) {
   try {
     const logOutput = execFileSync(
       'git', ['log', branch, '--not', 'main', '--oneline'],
-      { cwd: PROJECT_DIR, stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }
+      { windowsHide: true, cwd: PROJECT_DIR, stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }
     ).toString().trim();
     snapshot.logOk = true;
     snapshot.commitLines = logOutput ? logOutput.split('\n').filter(Boolean) : [];
@@ -339,7 +339,7 @@ function captureGitCommitSnapshot(taskId) {
   try {
     snapshot.numstatOutput = execFileSync(
       'git', ['log', branch, '--not', 'main', '--numstat', '--format='],
-      { cwd: PROJECT_DIR, stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }
+      { windowsHide: true, cwd: PROJECT_DIR, stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }
     ).toString().trim();
   } catch {
     // No numstat — non-fatal, mirrors original tolerance for this failure
@@ -446,7 +446,7 @@ function detectGitCommitPattern(taskId, guard, taskData, postCompleteResult) {
     try {
       logOutput = execFileSync(
         'git', ['log', branch, '--not', 'main', '--oneline'],
-        { cwd: PROJECT_DIR, stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }
+        { windowsHide: true, cwd: PROJECT_DIR, stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }
       ).toString().trim();
     } catch {
       return { result: null, reason: 'git_log_failed' };
@@ -463,7 +463,7 @@ function detectGitCommitPattern(taskId, guard, taskData, postCompleteResult) {
     try {
       numstatOutput = execFileSync(
         'git', ['log', branch, '--not', 'main', '--numstat', '--format='],
-        { cwd: PROJECT_DIR, stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }
+        { windowsHide: true, cwd: PROJECT_DIR, stdio: ['ignore', 'pipe', 'ignore'], timeout: 10000 }
       ).toString().trim();
     } catch {
       // No numstat — still evaluate revert/signature above

package/core/.specialist/tools/handoff-doc.js

@@ -24,7 +24,7 @@ function stamp(d) {
 }
 
 function git(projectPath, args) {
-  try { return execFileSync('git', args, { cwd: projectPath, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return ''; }
+  try { return execFileSync('git', args, { windowsHide: true, cwd: projectPath, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim(); } catch { return ''; }
 }
 
 function template({ topic, session, projectPath, now }) {

package/core/.specialist/tools/lessons.js

@@ -258,13 +258,13 @@ function rm(id, o = {}) {
   return l;
 }
 
-/** Project lessons for the dispatch prompt: facts (paths overlap scope_paths) and checks; bounded, most-fired first. */
+/** Project lessons for the dispatch prompt: facts and checks whose paths overlap scope_paths (no paths = every card); bounded, most-fired first. */
 function dispatchLessons(projectPath, scopePaths = [], { home, now } = {}) {
   const norm = (s) => String(s).replace(/\\/g, '/').toLowerCase();
   const scope = scopePaths.map(norm);
   const overlaps = (l) => !l.paths.length || l.paths.some((p) => scope.some((s) => s.includes(norm(p)) || norm(p).includes(s)));
   const pick = listLayer('project', { projectPath, home, now })
-    .filter((l) => !l.triggers.length && ((l.type === 'fact' && overlaps(l)) || l.type === 'check'));
+    .filter((l) => !l.triggers.length && (l.type === 'fact' || l.type === 'check') && overlaps(l));
   const out = { facts: [], checks: [] };
   let bytes = 0, lines = 0;
   for (const l of pick) {

package/core/CLAUDE.md

@@ -61,7 +61,7 @@ harness 預設「每條記憶都在 MEMORY.md 加一行」；本專案改為三
 KenazAI 是一個 Claude Code 多 Agent 協作系統，包含：
 - **kenaz-server**：Rust 後端（`dashboard/src-tauri/`，npm `@kenazai/server-*`）；Dashboard 桌面版已於 2026-10-11 退役（TASK_2396）
 - **Specialist 系統**：AI Agent 調度引擎（`.specialist/`）
-- **Formation 系統**：多 Agent 協作調度，支援 unit/solo/squad/legion 陣型（`.formation/`）
+- **Formation 工具**：subagent worktree 派工與合併工具（`.formation/tools/`）；unit/solo/squad/legion 與 `kenaz_dispatch` 已退役，只剩 subagent 派工
 
 技術棧：Rust（kenaz-server）、Node.js（kenaz CLI、hooks、工具）、SQLite
 
@@ -72,7 +72,7 @@ KenazAI 是一個 Claude Code 多 Agent 協作系統，包含：
 | Specialist | 定位 | 指令 |
 |-----------|------|------|
 | **Ansuz** ᚨ | 產品全生命週期引擎（需求→架構→任務→執行） | `/Ansuz` |
-| **Amelia** | Agent Center 調度者（多 Agent 協作） | `/Amelia` |
+| **Amelia** | 多 Agent 協作調度者 | `/Amelia` |
 
 文檔：`.specialist/Ansuz/SYSTEM_DOC.md`、`.specialist/Amelia/README.md`
 
@@ -128,7 +128,7 @@ node .collaboration/core/task-api.js move TASK_XXX active  # 移動狀態
 | 規則庫 | `.rule/` | 最高優先級規則，見 `INDEX.yaml` |
 | 失敗學習 | `.failure/` | 已知失敗模式，Agent 執行前應檢查 |
 | Rust 測試 | `npm run test:rust -- <filter>` | 主目錄直接可跑；用共用短路徑 target，不和其他建置搶 `target/` 鎖。勿直接 `cargo test` |
-| Formation | `.formation/` | 多 Agent 調度，見 `README.md` |
+| Formation | `.formation/` | subagent 派工與合併工具，見 `README.md` |
 | Skills | `.claude/skills/` | Agent 行為定義（40+ skills） |
 | 外部 Skills | `.agents/skills/` | `vercel-react-best-practices`、`supabase-postgres-best-practices` |
 
@@ -137,7 +137,7 @@ node .collaboration/core/task-api.js move TASK_XXX active  # 移動狀態
 KenazAI 支援管理子專案。Core 擁有系統檔，子專案只存 `.kenaz/`（tasks + logs + project.yaml）。
 
 子專案工作時：讀取 `.kenaz/project.yaml` 的 `core_path` 確定系統檔來源。
-task-api 和 Formation dispatch 都支援 `--project-path` 參數。
+task-api 和 `.formation/tools/dispatch.js` 都支援 `--project-path` 參數。
 
 文檔：`.system/collaboration/README.md`
 
@@ -155,7 +155,7 @@ DB:     postgresql://postgres:postgres@127.0.0.1:54322/postgres
 .rule/              # 規則庫（最高優先級）
 .specialist/        # Specialist 系統（Ansuz、Amelia）
 .collaboration/     # 任務系統
-.formation/         # Formation 調度
+.formation/         # subagent 派工與合併工具
 .failure/           # 失敗學習系統
 .memory/            # （歷史）舊記憶資料，記憶系統已移除
 .claude/            # Skills、Commands、Hooks

package/core/KENAZ_CORE_VERSION

@@ -1 +1 @@
-0.3.22
+0.3.24