@kybird/llm-wiki 0.4.0 → 0.4.2

package/README.md

@@ -49,7 +49,7 @@ That's it. The agent does the rest.
 | `llm-wiki lint` | Broken links, **evidence back-matching** (hash refs & `### Error` quotes must exist verbatim in `doc/raw/`), uncompiled concepts, metadata, staleness |
 | `llm-wiki board` / `board report` | Derived kanban view (text only, no flags) / dashboard (done:abandoned ratio, trend, QA reverts, waiting queue) |
 | `llm-wiki board video` | Replay `activity.jsonl` into a board timelapse MP4 (requires the `video/` Remotion project; CPU render, no GPU) |
-| `llm-wiki monitor [--port <n>]` | Live read-only board view at `http://127.0.0.1:<n>` (default 4747) — who claimed what and for how long (`zcode · 14분`), claim expiry, REVIEW questions, gates/dependency waits, the terminal pile (종결 적체 — newest done/superseded/abandoned with timestamps), and an activity stream. A **milestone panel** (purpose axis, plan.md 3.8) shows in-progress milestones expanded with their member cards and completed ones collapsed with progress — click a milestone to read its Goal (the plan's 대의) and full member list. Click any card (columns, terminal pile, activity rows) to read the full card file. Polls every 2s (re-renders only on change); the page renders agent-authored text via `textContent` only. Starting one while another monitor already listens is **idempotent** — exit 0, same URL (a port held by anything else fails with guidance). **The CLI stays the only writer** — every non-GET method gets a 405; the server keeps no state |
+| `llm-wiki monitor [--port <n>]` | Live read-only board view at `http://127.0.0.1:<n>` (default 4747) — who claimed what and for how long (`zcode · 14분`), claim expiry, REVIEW questions, gates/dependency waits, the terminal pile (종결 적체 — newest done/superseded/abandoned with timestamps), and an activity stream. A **milestone panel** (purpose axis, plan.md 3.8) shows in-progress milestones expanded with their member cards and completed ones collapsed with progress — click a milestone to read its Goal (the plan's 대의) and full member list. Click any card (columns, terminal pile, activity rows) to read the full card file. Polls every 2s (re-renders only on change); the page renders agent-authored text via `textContent` only. Starting one while **the same board's** monitor already listens is **idempotent** — exit 0, same URL. A port held by **another project's** monitor: default execution walks to the next free port (4747→4748→…, each board gets its own URL; the header shows the project name); an explicit `--port` fails with the owner's name. **`--all`** starts a **fleet view** — every llm-wiki project on this machine as tiles (WIP, review queue, milestone progress, last activity) with each project's full board one click away; projects register themselves in a machine-local registry (`~/.llm-wiki/projects.json`) as they run commands. **The CLI stays the only writer** — every non-GET method gets a 405; the server keeps no state |
 | `llm-wiki card new/show/edit` | Create and edit cards — the CLI is the only writer (sentinel-safe sections). `--kind milestone` creates a milestone card (the plan's 대의 lives in its Goal; not pickable, auto-completes when all members terminate); `--milestone "<title>"` attaches a card to one — membership is frontmatter, milestone progress is derived, never stored (plan.md 3.8) |
 | `llm-wiki pick --claim <name> [--card <title>]` | Atomically claim the next eligible card (lock, WIP limit, dependencies, claim expiry). `--card` claims a specific card by title — every gate still applies: a blocked pick prints why and leaves all files untouched, an unknown title fails (exit 1) |
 | `llm-wiki handoff <title> --question "…"` | Park a card for human judgment and release the claim |

package/bin/llm-wiki.js

@@ -35,9 +35,12 @@ Kanban (cards are files; CLI is the only writer):
   llm-wiki board                     Derived board view (columns, WIP, queue) — text only, no flags
   llm-wiki board report              Dashboard (done:abandoned ratio, trend, reverts)
   llm-wiki board video               Timelapse of board activity → MP4 (needs video/ project)
-  llm-wiki monitor [--port <n>]      Live read-only board view at http://127.0.0.1:<n>
-                                     (default 4747) — claims, elapsed, gates, activity;
-                                     the CLI stays the only writer (405 on writes)
+  llm-wiki monitor [--port <n>] [--all]  Live read-only board view at http://127.0.0.1:<n>
+                                     (default 4747, walks to the next free port past other
+                                     projects' monitors) — claims, elapsed, gates, activity;
+                                     --all = fleet view of EVERY llm-wiki project on this
+                                     machine (tiles + per-project boards); the CLI stays the
+                                     only writer (405 on any write method)
   llm-wiki card new "<title>"        Create card (--goal, --ac, --depends, --not-before;
                                      --kind milestone = milestone card, --milestone "<t>"
                                      attaches to one — plan-level grouping, plan.md 3.8)

package/lib/auto-update.js

@@ -50,6 +50,10 @@ function maybeAutoUpdate() {
     if (cfg.autoUpdate === false) return; // 옵트아웃 — init 재실행으로만 갱신
     if (process.env.LLM_WIKI_NO_AUTO_UPDATE === '1') return; // 일회성 끄기
 
+    // 기계의 프로젝트 등록부 — monitor --all(플릿)이 이 머신의 보드들을 아는
+    // 길이다. 버전 동기화와 무관하게 매번 갱신한다(마지막 본 시각 포함).
+    recordProject(docRoot, cfg);
+
     const sp = stampPath(root);
     if (readStamp(sp) === PKG_VERSION) return; // 이 버전으로 이미 동기화됨
 
@@ -76,4 +80,38 @@ function maybeAutoUpdate() {
   }
 }
 
-module.exports = { maybeAutoUpdate, stampPath };
+// ── 기계의 프로젝트 등록부 (monitor --all 플릿의 발견 소스) ─────────────────
+// <stateDir>/projects.json — { "<리포 절대경로>": { name, docRoot, lastSeen } }.
+// 능동 명령(maybeAutoUpdate)과 monitor 시작이 매번 갱신한다. 플릿은 파일이
+// 정본인 보드들을 직접 읽으므로, 이 등록부는 "어떤 프로젝트가 이 머신에 사나"의
+// 유일한 목록이다 — 스탬프 해시는 경로를 못 되돌려서 이 용도로 못 쓴다.
+function registryPath() {
+  return path.join(stateDir(), 'projects.json');
+}
+
+function recordProject(docRoot, cfg) {
+  try {
+    const root = path.dirname(path.resolve(docRoot));
+    const name = (cfg && cfg.projectName) || path.basename(root);
+    let data = {};
+    try { data = JSON.parse(fs.readFileSync(registryPath(), 'utf8')); } catch { /* 없음 — 첫 등록 */ }
+    data[root] = { name, docRoot: path.resolve(docRoot), lastSeen: new Date().toISOString() };
+    fs.mkdirSync(stateDir(), { recursive: true });
+    fs.writeFileSync(registryPath(), JSON.stringify(data, null, 2) + '\n');
+  } catch {
+    // 등록부는 부가 기능이다 — 실패가 명령을 막지 않는다(maybeAutoUpdate와 같은 규칙).
+  }
+}
+
+function readProjects() {
+  try {
+    const data = JSON.parse(fs.readFileSync(registryPath(), 'utf8'));
+    return Object.values(data)
+      .filter(p => p && p.docRoot && fs.existsSync(path.join(p.docRoot, 'kanban')))
+      .sort((a, b) => String(a.name).localeCompare(String(b.name)));
+  } catch {
+    return [];
+  }
+}
+
+module.exports = { maybeAutoUpdate, stampPath, recordProject, readProjects };

package/lib/kanban-cmd.js

@@ -116,8 +116,7 @@ function fail(message) {
 
 // 보드가 스캐폴드돼 있어야 한다 — 없으면 init으로 안내. 에러는 실제 탐색 루트와
 // LLM_WIKI_ROOT 값을 함께 보고한다 — 오버라이드가 다른 곳을 보고 있었다는 단서.
-function requireBoard() {
-  const docRoot = findDocRoot();
+function requireBoardAt(docRoot) {
   const paths = kanban.kanbanPaths(docRoot);
   if (!fs.existsSync(paths.kanbanDir)) {
     fail(`doc/kanban/ 이 없다 (${paths.kanbanDir}${process.env.LLM_WIKI_ROOT ? ` — LLM_WIKI_ROOT=${process.env.LLM_WIKI_ROOT}` : ''}). 먼저 \`llm-wiki init\`을 실행하라.`);
@@ -125,6 +124,10 @@ function requireBoard() {
   return { docRoot, paths, config: kanban.loadConfig(paths) };
 }
 
+function requireBoard() {
+  return requireBoardAt(findDocRoot());
+}
+
 function nowIso() { return localIso(); }
 
 // ── depends_on 검증 (card new/edit 공용) ──────────────────────────────────
@@ -183,7 +186,7 @@ const CARD_EDIT_FLAGS = {
   ac: 'string', 'add-ac': 'string', 'check-ac': 'string',
   note: 'string', 'renew-claim': 'flag',
   depends: 'string', 'add-depends': 'string', 'remove-depends': 'string',
-  milestone: 'string',
+  milestone: 'string', 'remove-milestone': 'flag',
 };
 
 // 각 명령의 사용법 문자열 — fail(인자 오류)과 bin의 --help 가드가 같은 문자열을
@@ -192,7 +195,7 @@ const CARD_EDIT_FLAGS = {
 const USAGE = {
   'card new': '사용법: llm-wiki card new "<제목>" [--goal …] [--ac …] [--depends a,b] [--not-before YYYY-MM-DD] [--kind milestone] [--milestone "<마일스톤 제목>"]',
   'card show': '사용법: llm-wiki card show <제목>',
-  'card edit': '사용법: llm-wiki card edit <제목> [--goal …] [--plan …] [--ac …] [--add-ac …] [--check-ac 1,2] [--note …] [--renew-claim] [--depends a,b] [--add-depends a,b] [--remove-depends a,b] [--milestone "<마일스톤 제목>"]',
+  'card edit': '사용법: llm-wiki card edit <제목> [--goal …] [--plan …] [--ac …] [--add-ac …] [--check-ac 1,2] [--note …] [--renew-claim] [--depends a,b] [--add-depends a,b] [--remove-depends a,b] [--milestone "<마일스톤 제목>"] [--remove-milestone]',
   card: '사용법: llm-wiki card <new|show|edit> …',
   handoff: '사용법: llm-wiki handoff <제목> --question "…"',
   done: '사용법: llm-wiki done <제목> --result "…" — Result 없는 완료는 거부한다.',
@@ -201,7 +204,7 @@ const USAGE = {
   reopen: '사용법: llm-wiki reopen <제목> --why "…" — 되돌림 사유가 기록되지 않으면 QA가 아니다.',
   resume: '사용법: llm-wiki resume <제목> [--note "…"]',
   board: '사용법: llm-wiki board — 텍스트 유도 뷰(플래그 없음). 하위: board report [--json] 대시보드 · board video 타임랩스',
-  monitor: '사용법: llm-wiki monitor [--port <번호>] — 읽기 전용 실시간 보드 뷰어(127.0.0.1, 기본 4747)',
+  monitor: '사용법: llm-wiki monitor [--port <번호>] [--all] — 읽기 전용 실시간 보드 뷰어(127.0.0.1, 기본 4747부터 빈 포트 탐색). --all은 이 머신 전체 프로젝트 집계(플릿)',
   pick: '사용법: llm-wiki pick [--claim <이름>] [--card "<제목>"] — --card 없으면 ordinal 최저를 집는다',
 };
 
@@ -232,6 +235,11 @@ function validateMilestoneTarget(paths, milestoneTitle, selfKind) {
   if (selfKind === 'milestone') {
     fail(`마일스톤 카드는 다른 마일스톤에 속할 수 없다(평면 — plan.md 3.8): ${milestoneTitle}`);
   }
+  // 종결 마일스톤은 회고 이력이다 — 산 멤버를 붙이면 "종결된 계획 아래 진행 중
+  // 카드"라는 썩은 상태가 되고, 자동 종결도 이미 종결 상태를 못 되돌아본다.
+  if (kanban.TERMINAL_FOLDERS.includes(target.meta.status)) {
+    fail(`종결된 마일스톤(${target.meta.status})에는 소속을 걸 수 없다: ${milestoneTitle} — 새 마일스톤을 만들거나 reopen으로 되돌려라.`);
+  }
 }
 
 function cardNew(paths, config, { positional, flags }) {
@@ -417,6 +425,18 @@ function cardEdit(paths, { positional, flags }) {
         changes.push(`milestone=${milestoneTitle}`);
       }
     }
+    // --remove-milestone — 잘못 건 소속 해제. 없는 걸 지우면 오타일 확률이 높다
+    // (--remove-depends와 같은 규칙). 종결 카드의 소속은 회고 이력이라 해제도 불허.
+    if (flags['remove-milestone']) {
+      if (!kanban.ACTIVE_STATUSES.includes(cardObj.meta.status)) {
+        fail(`종결 카드(${cardObj.meta.status})의 마일스톤은 바꾸지 않는다 — 회고 뷰가 읽는 이력이다: ${cardObj.filePath}`);
+      }
+      if (!meta.milestone) {
+        fail(`제거할 마일스톤 소속이 이 카드에 없다: ${title}`);
+      }
+      delete meta.milestone;
+      changes.push('milestone -해제');
+    }
 
     // --renew-claim — 긴 카드는 타임아웃 전에 클레임을 갱신한다 (루프 스킬 규칙 6).
     // 클레임은 만료 있는 협동 락이므로, 살아있는 작업자는 주기적으로 시각을 다시 심는다.
@@ -831,8 +851,14 @@ function abandon(options = {}) {
 // ── board — 유도 뷰 ──────────────────────────────────────────────────────
 
 // 카드가 정본이고 이 출력은 유도물이다 (3.7 원칙 2 — 갱신을 강제하지 않는다).
+// collectBoard() — 이 보드(cwd 기준). collectBoardAt(docRoot) — 플릿(monitor --all)이
+// 다른 프로젝트의 보드를 같은 계산으로 유도하기 위한 진입점.
 function collectBoard() {
-  const { paths, config } = requireBoard();
+  return collectBoardAt(findDocRoot());
+}
+
+function collectBoardAt(docRoot) {
+  const { paths, config } = requireBoardAt(docRoot);
   const active = kanban.listCardsInDir(paths.cardsDir);
   // 마일스톤 카드는 컬럼(작업 축)이 아니라 마일스톤 패널(목적 축)에만 나온다(3.8).
   const byStatus = status => active
@@ -904,6 +930,10 @@ function collectBoard() {
   const view = {
     schemaVersion: 1,
     kind: 'kanban-board',
+    // 보드 신원 — 모니터 멀티 인스턴스가 "같은 보드 재사용 vs 다음 포트"를 판정하는
+    // 키다(2026-09-17 접수 결함: 타 프로젝트 모니터를 가로채던 재사용). 읽기 전용
+    // localhost 뷰이므로 로컬 경로 노출은 안전하다. 이름은 리포 디렉터리(doc의 부모).
+    repo: { name: config.projectName || path.basename(path.dirname(docRoot)), docRoot },
     generatedAt: new Date().toISOString(),
     wip: { doing: { used: byStatus('doing').length, limit: config.wipLimits.doing } },
     columns: {
@@ -1247,5 +1277,6 @@ module.exports = {
   // monitor(kanban-monitor)가 보드 수집·루트 검증을 재사용한다 — 유도물은 한 곳에서.
   requireBoard,
   collectBoard,
+  collectBoardAt,
   scaffold: kanban.scaffold,
 };

package/lib/kanban-monitor.js

@@ -14,71 +14,104 @@
 // 그래서 monitor는 bin의 auto-update 트리거 목록에 없다(wait와 같은 이유 —
 // 배너가 첫 줄을 밀어내면 계약이 깨진다).
 const http = require('http');
+const fs = require('fs');
 const kanban = require('./kanban');
+const { recordProject, readProjects } = require('./auto-update');
 const {
-  parseArgs, validateFlags, fail, USAGE, requireBoard, collectBoard,
+  parseArgs, validateFlags, fail, USAGE, requireBoard, collectBoard, collectBoardAt,
 } = require('./kanban-cmd');
 
-const MONITOR_FLAGS = { port: 'string' };
+const MONITOR_FLAGS = { port: 'string', all: 'flag' };
 const DEFAULT_PORT = 4747;
+const PORT_SPAN = 10;
+// 테스트 노브(wait의 LLM_WIKI_WAIT_POLL_MS 전례) — 기본 포트 워크의 시작점을
+// 바꾼다. 병렬 테스트가 4747을 두고 경합하지 않게.
+const basePort = () => {
+  const env = Number(process.env.LLM_WIKI_MONITOR_BASE_PORT);
+  return Number.isInteger(env) && env > 0 ? env : DEFAULT_PORT;
+};
 
-// 이미 떠 있는 인스턴스가 우리 모니터인지 본다 — /api/board가 kanban-board를
-// 내면 ours. 루프가 매 시작마다 monitor를 띄우므로 재기동은 멱등이어야 한다
-// (멱등 재시도≠실패 — agent-cli-contract).
+// 이미 떠 있는 인스턴스를 본다 — /api/board가 kanban-board를 내면 monitor이고
+// 보드 신원(repo.docRoot)까지 돌려준다. /api/fleet이 kanban-fleet을 내면 플릿
+// (기계 단위 집계 뷰)이다. 루프가 매 시작마다 monitor를 띄우므로 재기동은
+// 멱등이어야 한다(멱등 재시도≠실패 — agent-cli-contract). 단 **같은 보드만
+// 재사용한다** — 다른 프로젝트의 모니터를 가로채던 결함(2026-09-17
+// 접수)의 수습이다. 구버전(0.4.0) 응답은 신원이 없어 docRoot=null.
 function probeExistingMonitor(port) {
-  return new Promise(resolve => {
-    const req = http.get({ host: '127.0.0.1', port, path: '/api/board', timeout: 1500 }, res => {
+  const get = apiPath => new Promise(resolve => {
+    const req = http.get({ host: '127.0.0.1', port, path: apiPath, timeout: 1500 }, res => {
       let body = '';
       res.setEncoding('utf8');
       res.on('data', d => { body += d; });
       res.on('end', () => {
-        try { resolve(JSON.parse(body).kind === 'kanban-board' ? 'ours' : 'foreign'); }
-        catch { resolve('foreign'); }
+        try { resolve(JSON.parse(body)); } catch { resolve(null); }
       });
     });
-    req.on('error', () => resolve('none'));
-    req.on('timeout', () => { req.destroy(); resolve('none'); });
+    req.on('error', () => resolve(null));
+    req.on('timeout', () => { req.destroy(); resolve(null); });
   });
+  return (async () => {
+    const board = await get('/api/board');
+    if (board && board.kind === 'kanban-board') {
+      return { state: 'monitor', docRoot: board.repo && board.repo.docRoot, name: board.repo && board.repo.name };
+    }
+    const fleet = await get('/api/fleet');
+    if (fleet && fleet.kind === 'kanban-fleet') return { state: 'fleet' };
+    // 응답은 있지만 우리 API가 아니다 — 남의 프로세스.
+    return { state: (board === null && fleet === null) ? 'none' : 'foreign' };
+  })();
 }
 
-async function monitor(options = {}) {
-  const flags = { ...parseArgs(options.rest || []).flags };
-  if (options.json) flags.json = true;
-  validateFlags(flags, MONITOR_FLAGS);
-
-  const port = flags.port !== undefined ? Number(flags.port) : DEFAULT_PORT;
-  if (!Number.isInteger(port) || port < 0 || port > 65535) {
-    fail(`--port 값이 잘못됐다: ${flags.port} — 0~65535의 정수(0은 임시 포트 할당). ${USAGE.monitor}`);
-  }
+function reusePrint(port) {
+  console.log(`http://127.0.0.1:${port}`);
+  console.log('이미 떠 있다 — 이 보드의 모니터를 재사용한다 (멱등 재시도).');
+}
 
-  // 시작 시 한 번 검증한다 — requireBoard의 fail은 process.exit(1)이라 요청
-  // 도중에 돌리면 서버가 그대로 죽는다. 이후 요청에서 보드가 사라지면 500.
-  const { paths } = requireBoard();
-
-  // 고정 포트에 이미 우리 모니터가 떠 있으면 재사용(exit 0) — 루프 시작이 몇 번을
-  // 불러도 첫 번째만 듣고 나머지는 URL만 되뇐다. 임시 포트(0)는 재사용 의미가 없다.
-  if (port !== 0) {
-    const existing = await probeExistingMonitor(port);
-    if (existing === 'ours') {
-      console.log(`http://127.0.0.1:${port}`);
-      console.log('이미 떠 있다 — 이 모니터를 재사용한다 (멱등 재시도).');
-      return;
+function startMonitorServer(ctx, port) {
+  const server = http.createServer((req, res) => {
+    try {
+      handle(req, res, ctx);
+    } catch (e) {
+      if (!res.headersSent) {
+        res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' });
+      }
+      res.end(`보드를 읽다 실패했다: ${e.message}\n`);
     }
-  }
+  });
+  server.on('error', err => {
+    if (err.code === 'EADDRINUSE') {
+      console.error(`✗ 포트 ${port}가 이미 쓰이고 있다 — --port <다른 번호> 또는 기본 실행(빈 포트 자동 탐색).`);
+    } else {
+      console.error(`✗ 서버 오류: ${err.message}`);
+    }
+    process.exit(1);
+  });
+  server.listen(port, '127.0.0.1', () => {
+    const actual = server.address().port;
+    console.log(`http://127.0.0.1:${actual}`);
+    console.log(`읽기 전용 모니터 — 정본은 ${ctx.paths.kanbanDir} 의 카드 파일, 쓰는 건 CLI뿐이다. 종료는 Ctrl+C.`);
+  });
+  return server;
+}
 
+// ── 플릿(monitor --all) — 기계 단위 집계 뷰 ────────────────────────────────
+// 프로젝트 목록은 기계 등록부(auto-update의 projects.json)에서. 각 타일의 상태는
+// 그 프로젝트의 doc/kanban 파일을 직접 읽어 유도한다 — 서버끼리 통신하는 배관
+// 없음(파일이 정본). /p/<slug>/ 는 단일 보드 페이지·API를 그 프로젝트 경로로.
+function startFleetServer(port) {
   const server = http.createServer((req, res) => {
     try {
-      handle(req, res, paths);
+      handleFleet(req, res);
     } catch (e) {
       if (!res.headersSent) {
         res.writeHead(500, { 'content-type': 'text/plain; charset=utf-8' });
       }
-      res.end(`보드를 읽다 실패했다: ${e.message}\n`);
+      res.end(`플릿을 읽다 실패했다: ${e.message}\n`);
     }
   });
   server.on('error', err => {
     if (err.code === 'EADDRINUSE') {
-      console.error(`✗ 포트 ${port}가 이미 쓰이고 있다 — --port <다른 번호>로 바꿔라.`);
+      console.error(`✗ 포트 ${port}가 이미 쓰이고 있다 — --port <다른 번호> 또는 기본 실행(빈 포트 자동 탐색).`);
     } else {
       console.error(`✗ 서버 오류: ${err.message}`);
     }
@@ -87,23 +120,204 @@ async function monitor(options = {}) {
   server.listen(port, '127.0.0.1', () => {
     const actual = server.address().port;
     console.log(`http://127.0.0.1:${actual}`);
-    console.log(`읽기 전용 모니터 — 정본은 ${paths.kanbanDir} 의 카드 파일, 쓰는 건 CLI뿐이다. 종료는 Ctrl+C.`);
+    console.log('플릿 — 이 머신의 모든 llm-wiki 프로젝트를 한 페이지로. 종료는 Ctrl+C.');
   });
+  return server;
 }
 
-function handle(req, res, paths) {
+// 등록부 + 고유 슬러그(동명 리포는 -2 접미).
+function fleetProjects() {
+  const seen = new Set();
+  return readProjects().map(p => {
+    let slug = kanban.slugify(p.name || 'project');
+    if (seen.has(slug)) {
+      let i = 2;
+      while (seen.has(`${slug}-${i}`)) i += 1;
+      slug = `${slug}-${i}`;
+    }
+    seen.add(slug);
+    return { ...p, slug };
+  });
+}
+
+function fleetSummary() {
+  const projects = fleetProjects().map(p => {
+    try {
+      const { view, paths } = collectBoardAt(p.docRoot);
+      const activity = kanban.readActivity(paths);
+      const last = activity[activity.length - 1];
+      return {
+        // 이름은 등록부 우선(recordProject가 projectName|리포명으로 기록) — 보드
+        // 뷰의 재계산과 어긋나는 환경(오버라이드 루트)에서도 타일이 흔들리지 않게.
+        name: p.name || view.repo.name,
+        docRoot: p.docRoot,
+        slug: p.slug,
+        wip: view.wip,
+        counts: {
+          todo: view.columns.todo.length,
+          doing: view.columns.doing.length,
+          review: view.columns.review.length,
+        },
+        milestones: view.milestones.map(m => ({
+          title: m.title,
+          status: m.status,
+          finished: m.total - m.counts.active,
+          total: m.total,
+        })),
+        terminal: view.terminal,
+        lastActivity: last ? last.ts : null,
+      };
+    } catch {
+      return null; // 읽다 실패한 프로젝트는 타일에서만 빠진다 — 서버는 산다
+    }
+  }).filter(Boolean);
+  return { schemaVersion: 1, kind: 'kanban-fleet', generatedAt: new Date().toISOString(), projects };
+}
+
+function handleFleet(req, res) {
+  if (req.method !== 'GET') {
+    res.writeHead(405, { 'content-type': 'text/plain; charset=utf-8', allow: 'GET' });
+    res.end('카드 쓰기는 CLI뿐이다 — 이 서버는 읽기 전용이다.\n');
+    return;
+  }
   const url = new URL(req.url, 'http://127.0.0.1');
+  const noStore = { 'cache-control': 'no-store' };
+  if (url.pathname === '/' || url.pathname === '') {
+    res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', ...noStore });
+    res.end(renderFleetPage());
+  } else if (url.pathname === '/api/fleet') {
+    res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', ...noStore });
+    res.end(JSON.stringify(fleetSummary()));
+  } else {
+    const m = url.pathname.match(/^\/p\/([^/]+)(\/.*)?$/);
+    if (m) {
+      const entry = fleetProjects().find(p => p.slug === decodeURIComponent(m[1]));
+      if (!entry) {
+        res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+        res.end('등록부에 없는 프로젝트다 — /api/fleet 목록을 보라.\n');
+        return;
+      }
+      const paths = kanban.kanbanPaths(entry.docRoot);
+      const rest = m[2] || '/';
+      // /p/<slug>/ → 보드 페이지, /p/<slug>/api/… → 그 보드의 API(같은 처리기).
+      serveBoard(req, res, { docRoot: entry.docRoot, paths }, new URL(rest + url.search, 'http://127.0.0.1'));
+      return;
+    }
+    res.writeHead(404, { 'content-type': 'text/plain; charset=utf-8' });
+    res.end('없는 경로다 — / · /api/fleet · /p/<프로젝트>/.\n');
+  }
+}
+
+async function monitor(options = {}) {
+  const flags = { ...parseArgs(options.rest || []).flags };
+  if (options.json) flags.json = true;
+  validateFlags(flags, MONITOR_FLAGS);
+
+  const port = flags.port !== undefined ? Number(flags.port) : DEFAULT_PORT;
+  if (!Number.isInteger(port) || port < 0 || port > 65535) {
+    fail(`--port 값이 잘못됐다: ${flags.port} — 0~65535의 정수(0은 임시 포트 할당). ${USAGE.monitor}`);
+  }
+
+  // 시작 시 한 번 검증한다 — requireBoard의 fail은 process.exit(1)이라 요청
+  // 도중에 돌리면 서버가 그대로 죽는다. 이후 요청에서 보드가 사라지면 500.
+  const { docRoot, paths, config } = requireBoard();
+  const ctx = { docRoot, paths };
+  // 기계 등록부 — 이 프로젝트를 플릿(--all)이 발견하게 한다. 능동 명령이
+  // 기록하는 것과 같은 파이프(maybeAutoUpdate → recordProject).
+  recordProject(docRoot, config);
+
+  // --all — 기계 단위 집계 뷰(플릿). 재사용은 "다른 플릿"만: 어느 프로젝트가
+  // 띄웠든 플릿은 하나면 충분하다.
+  if (flags.all) {
+    if (port === 0) {
+      startFleetServer(0);
+      return;
+    }
+    if (flags.port !== undefined) {
+      const found = await probeExistingMonitor(port);
+      if (found.state === 'fleet') {
+        reusePrint(port);
+        return;
+      }
+      if (found.state === 'monitor') {
+        fail(`포트 ${port}는 보드 모니터가 쓰고 있다(${found.name || '신원 없음'}) — 플릿은 기본 실행(빈 포트 자동 탐색)이나 다른 포트로 띄워라.`);
+      }
+      startFleetServer(port);
+      return;
+    }
+    const base = basePort();
+    for (let p = base; p < base + PORT_SPAN; p++) {
+      const found = await probeExistingMonitor(p);
+      if (found.state === 'none') { startFleetServer(p); return; }
+      if (found.state === 'fleet') { reusePrint(p); return; }
+    }
+    fail(`${base}–${base + PORT_SPAN - 1}에 빈 포트가 없다 — --port <번호>로 직접 지정하라.`);
+  }
+
+  // 임시 포트(0)는 검사·재사용이 무의미하다 — 그냥 듣는다.
+  if (port === 0) {
+    startMonitorServer(ctx, 0);
+    return;
+  }
+
+  // --port 명시는 엄격하다: 같은 보드의 모니터면 재사용(exit 0), 다른 프로젝트
+  // 소유면 이름을 말하며 실패 — 조용히 남의 보드로 안내하는 게 이 결함의 본체였다.
+  if (flags.port !== undefined) {
+    const found = await probeExistingMonitor(port);
+    if (found.state === 'monitor') {
+      if (found.docRoot === docRoot) {
+        reusePrint(port);
+        return;
+      }
+      const who = found.name || found.docRoot || '신원 없음(구버전 monitor)';
+      fail(`포트 ${port}는 다른 프로젝트의 모니터가 쓰고 있다(${who}) — 같은 포트 재사용은 같은 보드만 된다. 기본 실행(빈 포트 자동 탐색)이나 --port <다른 번호>로 띄워라.`);
+    }
+    if (found.state === 'fleet') {
+      fail(`포트 ${port}는 플릿(monitor --all)이 쓰고 있다 — 보드 모니터는 기본 실행이나 다른 포트로 띄워라.`);
+    }
+    // foreign/none — bind 시도. foreign이면 EADDRINUSE 핸들러가 안내한다.
+    startMonitorServer(ctx, port);
+    return;
+  }
+
+  // 기본 실행 — 시작 포트부터 차례로: 같은 보드의 모니터면 재사용, 다른
+  // 프로젝트·플릿·타 프로세스면 건너뛴다. 멀티 프로젝트 밤 시나리오(각 루프가 monitor를
+  // 띄움)에서 각자의 보드가 각자의 포트에 뜬다.
+  const base = basePort();
+  for (let p = base; p < base + PORT_SPAN; p++) {
+    const found = await probeExistingMonitor(p);
+    if (found.state === 'none') {
+      startMonitorServer(ctx, p);
+      return;
+    }
+    if (found.state === 'monitor' && found.docRoot === docRoot) {
+      reusePrint(p);
+      return;
+    }
+  }
+  fail(`${base}–${base + PORT_SPAN - 1}에 빈 포트가 없다 — --port <번호>로 직접 지정하라.`);
+}
+
+function handle(req, res, ctx) {
+  serveBoard(req, res, ctx, new URL(req.url, 'http://127.0.0.1'));
+}
+
+// 단일 보드의 페이지+API — 플릿(/p/<slug>/…)도 프로젝트 경로와 (필요하면 다시
+// 쓴 URL과 함께) 같은 처리기를 재사용한다. 상대 fetch 덕에 페이지 코드는 한 벌.
+function serveBoard(req, res, ctx, url) {
+  const paths = ctx.paths;
   if (req.method !== 'GET') {
     res.writeHead(405, { 'content-type': 'text/plain; charset=utf-8', allow: 'GET' });
     res.end('카드 쓰기는 CLI뿐이다 — 이 서버는 읽기 전용이다.\n');
     return;
   }
   const noStore = { 'cache-control': 'no-store' };
-  if (url.pathname === '/') {
+  if (url.pathname === '/' || url.pathname === '') {
     res.writeHead(200, { 'content-type': 'text/html; charset=utf-8', ...noStore });
     res.end(renderMonitorPage());
   } else if (url.pathname === '/api/board') {
-    const { view } = collectBoard();
+    // 이 보드의 것만 — 플릿 경로로도 ctx.docRoot가 그 프로젝트를 가리킨다.
+    const { view } = collectBoardAt(ctx.docRoot);
     res.writeHead(200, { 'content-type': 'application/json; charset=utf-8', ...noStore });
     res.end(JSON.stringify(view));
   } else if (url.pathname === '/api/activity') {
@@ -240,7 +454,7 @@ function renderMonitorPage() {
 </head>
 <body>
 <header>
-  <h1>llm-wiki monitor</h1>
+  <h1>llm-wiki monitor <span id="project" class="who"></span></h1>
   <p id="summary">불러오는 중…</p>
 </header>
 <section id="milestones" hidden>
@@ -439,6 +653,9 @@ let lastBoard = null;
 function updateSummary() {
   const summary = document.getElementById('summary');
   if (!lastBoard) return;
+  // 프로젝트 이름 — 여러 탭(멀티 프로젝트)을 구분하는 표지다.
+  const projName = lastBoard.repo && lastBoard.repo.name;
+  document.getElementById('project').textContent = projName ? '· ' + projName : '';
   const t = lastBoard.terminal;
   summary.className = '';
   summary.textContent = 'WIP doing ' + lastBoard.wip.doing.used + '/' + lastBoard.wip.doing.limit +
@@ -449,7 +666,7 @@ function updateSummary() {
 async function tick() {
   const summary = document.getElementById('summary');
   try {
-    const [b, a] = await Promise.all([fetch('/api/board'), fetch('/api/activity')]);
+    const [b, a] = await Promise.all([fetch('api/board'), fetch('api/activity')]);
     if (!b.ok || !a.ok) throw new Error('HTTP ' + b.status + '/' + a.status);
     const board = await b.json();
     const activity = await a.json();
@@ -490,7 +707,7 @@ async function openCard(title) {
   metaEl.textContent = '';
   body.replaceChildren(el('div', 'sec', '불러오는 중…'));
   try {
-    const r = await fetch('/api/card?title=' + encodeURIComponent(title));
+    const r = await fetch('api/card?title=' + encodeURIComponent(title));
     if (!r.ok) throw new Error(r.status === 404 ? '카드를 못 찾았다 — 제목이 바뀌었거나 아직 안 만들어졌다' : 'HTTP ' + r.status);
     const data = await r.json();
     t.textContent = data.title;
@@ -541,4 +758,99 @@ tick();
 `;
 }
 
-module.exports = { monitor, renderMonitorPage };
+// ── 플릿 페이지 — 이 머신의 프로젝트 타일. 데이터는 textContent만. ───────────
+function renderFleetPage() {
+  return `<!doctype html>
+<html lang="ko">
+<head>
+<meta charset="utf-8">
+<title>llm-wiki fleet</title>
+<style>
+  body { font-family: -apple-system, 'Segoe UI', 'Malgun Gothic', sans-serif; margin: 20px;
+         background: #0f141a; color: #d7dee6; }
+  header h1 { font-size: 18px; margin: 0 0 4px; }
+  header p { margin: 0 0 16px; color: #7f8b98; font-size: 13px; }
+  main { display: grid; grid-template-columns: repeat(auto-fill, minmax(280px, 1fr)); gap: 12px; }
+  a.tile { display: block; background: #161d26; border: 1px solid #232d3a; border-radius: 10px;
+           padding: 12px; text-decoration: none; color: #d7dee6; }
+  a.tile:hover { border-color: #48596d; }
+  .tile h2 { font-size: 15px; margin: 0 0 8px; }
+  .tile .line { font-size: 12px; color: #9fb0c0; margin: 3px 0; }
+  .fbar { height: 5px; background: #10161d; border-radius: 999px; overflow: hidden; margin: 4px 0; }
+  .fbar-fill { height: 100%; background: linear-gradient(90deg, #2f6f4f, #6ee7a0); }
+  .badge { display: inline-block; font-size: 11px; background: #26313f; color: #a9b7c4;
+           border-radius: 999px; padding: 2px 8px; margin: 2px 4px 0 0; }
+  .badge.warn { background: #4a2f14; color: #ffb45e; }
+  .who { color: #8a97a3; font-size: 11px; }
+  .empty { color: #55616d; font-size: 13px; }
+</style>
+</head>
+<body>
+<header>
+  <h1>llm-wiki fleet <span class="who">— 이 머신의 모든 프로젝트</span></h1>
+  <p id="summary">불러오는 중…</p>
+</header>
+<main id="tiles"></main>
+<script>
+'use strict';
+const el = (tag, cls, text) => {
+  const n = document.createElement(tag);
+  if (cls) n.className = cls;
+  if (text !== undefined) n.textContent = text;
+  return n;
+};
+const fmtDayClock = ts => {
+  const d = new Date(ts);
+  const pad = n => String(n).padStart(2, '0');
+  return (d.getMonth() + 1) + '월 ' + d.getDate() + '일 ' + pad(d.getHours()) + ':' + pad(d.getMinutes());
+};
+let lastSig = '';
+async function tick() {
+  const summary = document.getElementById('summary');
+  try {
+    const r = await fetch('api/fleet');
+    if (!r.ok) throw new Error('HTTP ' + r.status);
+    const fleet = await r.json();
+    const sig = JSON.stringify({ ...fleet, generatedAt: null });
+    summary.className = '';
+    summary.textContent = '프로젝트 ' + fleet.projects.length + ' · 갱신 ' + new Date().toLocaleTimeString('ko-KR', { hour12: false });
+    if (sig === lastSig) return; // 변화 없으면 DOM을 다시 짓지 않는다(클릭 보호)
+    lastSig = sig;
+    const tiles = document.getElementById('tiles');
+    tiles.replaceChildren(...fleet.projects.map(p => {
+      const a = el('a', 'tile');
+      a.href = 'p/' + encodeURIComponent(p.slug) + '/';
+      a.append(el('h2', '', p.name));
+      const status = el('div');
+      status.append(el('span', 'badge', 'doing ' + p.counts.doing + '/' + p.wip.doing.limit));
+      if (p.counts.review) status.append(el('span', 'badge warn', '판정 대기 ' + p.counts.review));
+      if (p.counts.todo) status.append(el('span', 'badge', 'todo ' + p.counts.todo));
+      a.append(status);
+      for (const m of (p.milestones || []).slice(0, 4)) {
+        const row = el('div', 'line', (['todo', 'doing', 'review'].includes(m.status) ? '• ' : '✓ ') + m.title + ' ' + m.finished + '/' + m.total);
+        const bar = el('div', 'fbar');
+        const fill = el('div', 'fbar-fill');
+        fill.style.width = (m.total ? Math.round(m.finished / m.total * 100) : 0) + '%';
+        bar.append(fill);
+        a.append(row, bar);
+      }
+      const t = p.terminal;
+      const foot = el('div', 'who', '종결 done ' + t.done + ' · superseded ' + t.superseded + ' · abandoned ' + t.abandoned +
+        (p.lastActivity ? ' · 마지막 활동 ' + fmtDayClock(p.lastActivity) : ''));
+      a.append(foot);
+      return a;
+    }));
+    if (!fleet.projects.length) tiles.append(el('div', 'empty', '등록된 프로젝트가 없다 — 각 프로젝트에서 llm-wiki 명령을 한 번씩 실행하면 등록부에 오른다.'));
+  } catch (e) {
+    summary.textContent = '연결 끊김 (' + e.message + ')';
+  }
+}
+setInterval(tick, 2000);
+tick();
+</script>
+</body>
+</html>
+`;
+}
+
+module.exports = { monitor, renderMonitorPage, renderFleetPage };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kybird/llm-wiki",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "LLM-friendly knowledge graph + kanban for AI coding agents. Raw daily logs → compiled wiki → merged semantic+grep search, and a card-per-file kanban the work-loop skill consumes unattended. Drop-in for any repo.",
   "license": "MIT",
   "author": "kybird",

package/skills/work-loop/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: work-loop
 description: Unattended kanban loop — pick a card, resolve it with objective evidence, park judgment calls and move on. Board is the only task list; converge, don't diverge.
-skill-version: 7
+skill-version: 8
 ---
 # When to use
 
@@ -21,10 +21,12 @@ skill-version: 7
 # Loop start — bring the monitor up (사람의 실시간 관측)
 
 루프를 시작할 때 `llm-wiki monitor`를 백그라운드로 띄운다 — 밤중에 사람이 들어와도
-클레임·진행·마일스톤이 살아 있는 보드를 본다. **멱등이다**: 이미 떠 있으면 exit 0으로
-같은 URL을 되뇌므로 그대로 쓰고, 백그라운드 실행이 안 되는 환경이면 건너뛴다 —
-모니터는 관측이지 의존성이 아니다. 정지 규칙에서도 모니터는 끄지 않는다(아침의
-사람이 본다) — 읽기 전용이라 남겨두는 비용이 없다.
+클레임·진행·마일스톤이 살아 있는 보드를 본다. **멱등이다**: 이 루프의 보드(같은
+프로젝트) 모니터가 이미 떠 있으면 exit 0으로 같은 URL을 되뇐다. 다른 프로젝트의
+모니터가 기본 포트를 쓰고 있으면 **다음 포트에 자기 보드를 띄운다** — 멀티
+프로젝트 밤에도 각자의 보드가 각자의 URL에 뜬다. 백그라운드 실행이 안 되는
+환경이면 건너뛴다 — 모니터는 관측이지 의존성이 아니다. 정지 규칙에서도 모니터는
+끄지 않는다(아침의 사람이 본다) — 읽기 전용이라 남겨두는 비용이 없다.
 
 # Loop graph