lostvibe 0.7.0 → 0.8.0

package/README.md

@@ -16,25 +16,58 @@ AI 코딩 도구(Claude Code, Codex 등)의 로컬 로그와 git에서 **날짜
 AI가 아래 명령을 대신 실행한다.
 
 ```
-npx -y lostvibe@0.7.0 setup --token <사이트에서 받은 토큰>
-npx -y lostvibe@0.7.0 draft --file .lostvibe/project.json
-npx -y lostvibe@0.7.0 sync
+npx -y lostvibe@0.8.0 setup --token <사이트에서 받은 토큰>
+npx -y lostvibe@0.8.0 draft --file .lostvibe/project.json
+npx -y lostvibe@0.8.0 sync
 ```
 
+여러 프로젝트를 한 번에 가져올 때:
+
+```
+lostvibe scan --all --json                    # 목록(JSON)만 출력. 고를 때 쓴다
+lostvibe setup                                # setup:"folder" 인 프로젝트: 그 폴더에서 (git 없어도 된다)
+lostvibe setup --source <id>                  # setup:"source" 인 프로젝트: 로그만 남은 것, 어느 폴더에서나
+lostvibe setup --merge <id>[,<id>]            # 같은 프로젝트의 다른 폴더 기록을 합친다 (주 프로젝트 폴더에서)
+lostvibe draft --file .lostvibe/project.json --of <N>          # N: 이번에 가져오는 프로젝트 수 (1~200)
+lostvibe draft --file project.json --project <프로젝트 id> --of <N>   # 폴더 없는 프로젝트
+```
+
+`scan --all --json` 출력: `{"projects":[{"n","id","name","tokens","last","path","exists","git","setup","url"}]}`.
+경로가 들어간 전체 목록은 `~/.lostvibe/scan-all.json`(권한 600)에만 저장되고 보내지 않는다.
+
 토큰은 비밀이다. 화면·코드·저장소 어디에도 남기지 않는다.
 
+## 자동 갱신 훅
+
+`hooks install`은 Claude Code와 Codex에 `Stop`, `SessionEnd` 훅을 넣는다. 다른 훅은 건드리지 않고,
+예전 버전이 넣은 Lost Vibe 훅은 찾아서 바꾼다. 훅은 항상 `~/.lostvibe/runtime/current`를 실행하므로
+버전을 올려도 명령이 같아서 Codex를 다시 승인할 필요가 없다. `Stop`은 프로젝트마다 10분에 한 번만 동기화한다.
+
+`hooks status`는 클라이언트마다 `미설치` / `설치됨·승인 전` / `승인됨·실행 기록 없음` / `실행됨`을 보여 준다.
+Claude Code는 승인이 필요 없다. Codex는 Codex CLI에서 `/hooks`를 열고 Lost Vibe 항목 2개를 Trust 해야 한다.
+
 ## 명령
 
 ```
-lostvibe scan [폴더]       폴더 하나를 읽어 그 폴더에 lostvibe.json 저장
-lostvibe scan --all        로그 전체에서 내 프로젝트를 전부 찾아 표로 출력
-lostvibe setup             현재 프로젝트만 비공개로 등록하고 이 컴퓨터와 연결
-lostvibe draft --file F    AI가 만든 JSON을 검토할 초안으로 보낸다
-lostvibe sync              등록한 프로젝트의 바뀐 기록만 올린다
-lostvibe hooks install     기존 훅을 보존하며 자동 갱신 연결
-lostvibe hooks status      설치 상태 확인
-lostvibe hooks remove      Lostvibe가 추가한 항목만 제거
-lostvibe collect           연결한 성과를 읽어 갱신
+lostvibe scan [폴더]             폴더 하나를 읽어 그 폴더에 lostvibe.json 저장
+lostvibe scan --all [--json]     로그 전체에서 내 프로젝트를 전부 찾아 표(또는 JSON)로 출력
+lostvibe setup [--no-hooks]      현재 폴더의 프로젝트만 비공개로 등록하고 이 컴퓨터와 연결
+lostvibe setup --source ID       폴더 없이 로그만 남은 프로젝트를 등록
+lostvibe setup --merge ID[,ID]   scan --all 의 다른 프로젝트를 이 프로젝트에 합친다
+lostvibe draft --file F [--of N] [--project ID]
+                                 AI가 만든 JSON을 검토할 초안으로 보낸다
+lostvibe sync                    등록한 프로젝트의 바뀐 기록만 올린다
+lostvibe hooks install           기존 훅을 보존하며 자동 갱신 연결
+lostvibe hooks status            설치·승인·실행 상태 확인
+lostvibe hooks remove            Lostvibe가 추가한 항목만 제거
+lostvibe collector add --project ID --slot result --command-json '[...]' [--cwd 폴더]
+                                 성과 조회 명령 등록 (--cwd 는 프로젝트 폴더 안)
+lostvibe collector test --command-json '[...]' [--cwd 폴더]
+                                 보내지 않고 실행만 해서 "값: N (날짜)" 또는 실패 종류를 보여 준다
+lostvibe collect                 연결한 성과를 읽어 갱신
 ```
 
+`collector test` 실패 종류: 환경 변수 없음 / 모듈을 찾지 못함 / 테이블 없음 / DB 연결 실패 / JSON 형식 오류 / 시간 초과 / 알 수 없는 오류.
+명령의 출력과 오류 내용은 화면에 내보내지 않는다.
+
 Node 22.15 이상. MIT.

package/bin/lostvibe.mjs

@@ -4,13 +4,16 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { execFileSync, spawn } from 'node:child_process';
-import { scanAll, stripLocal, readJson } from '../src/scan.mjs';
+import { scanAll, stripLocal, readJson, scanEntry } from '../src/scan.mjs';
 import { landTable, projectTable } from '../src/table.mjs';
 import { askReported } from '../src/reported.mjs';
 import { resolveCwd, sha, projectIdentity } from '../src/gitinfo.mjs';
 import { push } from '../src/push.mjs';
 import {
   registerCurrent,
+  registerProject,
+  setMerge,
+  mergeMap,
   activeConnection,
   selectedProjects,
   siteOf,
@@ -19,8 +22,8 @@ import {
   saveJson,
   currentIdentity,
 } from '../src/connections.mjs';
-import { addCollector, removeCollector, collect } from '../src/collectors.mjs';
-import { installHooks, removeHooks, hookStatus } from '../src/hooks.mjs';
+import { addCollector, removeCollector, collect, testCollector, collectorCwd } from '../src/collectors.mjs';
+import { installHooks, removeHooks, hookStatus, statusLines, installLines } from '../src/hooks.mjs';
 
 const DEFAULT_SITE = 'https://lostvibesociety.com';
 
@@ -44,6 +47,12 @@ function parse(argv) {
     else if (a === '--client') o.client = argv[++i];
     else if (a === '--no-hooks') o.noHooks = true;
     else if (a === '--only') o.only = argv[++i];
+    else if (a === '--json') o.json = true;
+    else if (a === '--source') o.source = argv[++i];
+    else if (a === '--merge') o.merge = argv[++i];
+    else if (a === '--of') o.of = argv[++i];
+    else if (a === '--from') o.from = argv[++i];
+    else if (a === '--cwd') o.cwd = argv[++i];
     else if (a === '-h' || a === '--help') o.help = true;
     else o._.push(a);
   }
@@ -54,15 +63,22 @@ const HELP = `lostvibe - 프로젝트의 객관 지표를 뽑는다
 
   lostvibe scan [폴더]       폴더 하나를 읽어 그 폴더에 lostvibe.json 저장
   lostvibe scan --all        로그 전체에서 내 프로젝트를 전부 찾아 표로 출력
+  lostvibe scan --all --json 같은 목록을 JSON 하나로만 출력 (~/.lostvibe/scan-all.json 에도 저장)
   lostvibe login --token T   이 컴퓨터를 내 땅에 연결한다
-  lostvibe setup             현재 프로젝트만 비공개로 등록하고 이 컴퓨터와 연결
-  lostvibe draft --file F     AI가 만든 JSON을 검토할 초안으로 보낸다
+  lostvibe setup             현재 폴더의 프로젝트를 비공개로 등록하고 이 컴퓨터와 연결 (git 없어도 돼요)
+  lostvibe setup --source ID 폴더 없이 로그만 남은 프로젝트를 등록 (scan --all 의 id, 어느 폴더에서나)
+  lostvibe setup --merge ID[,ID]
+                            scan --all 의 다른 프로젝트를 이 프로젝트 기록에 합친다
+  lostvibe draft --file F [--of N] [--project ID]
+                            AI가 만든 JSON을 검토할 초안으로 보낸다 (--of: 가져오는 프로젝트 수)
   lostvibe sync              등록한 프로젝트의 바뀐 기록만 올린다
-  lostvibe hooks install     기존 훅을 보존하며 자동 갱신 연결
-  lostvibe hooks status      설치 상태 확인 (Codex는 신뢰 검토도 필요)
-  lostvibe hooks remove      Lostvibe가 추가한 항목만 제거
-  lostvibe collector add --project ID --slot result --command-json '["node","script.mjs"]'
-                            프로젝트 성과 조회 명령을 등록
+  lostvibe hooks install     기존 훅을 보존하며 자동 갱신 연결 (Stop, SessionEnd)
+  lostvibe hooks status      클라이언트별 상태: 미설치 / 설치됨·승인 전 / 승인됨·실행 기록 없음 / 실행됨
+  lostvibe hooks remove      Lostvibe 훅만 제거
+  lostvibe collector add --project ID --slot result --command-json '["node","script.mjs"]' [--cwd 폴더]
+                            프로젝트 성과 조회 명령을 등록 (--cwd 는 프로젝트 폴더 안)
+  lostvibe collector test --command-json '[...]' [--cwd 폴더] [--project ID]
+                            보내지 않고 실행만 해서 값을 확인
   lostvibe collector remove --project ID --slot result
   lostvibe collect            연결한 성과를 읽어 갱신
   lostvibe push              --all 결과를 확인하고 올린다
@@ -76,6 +92,7 @@ const HELP = `lostvibe - 프로젝트의 객관 지표를 뽑는다
   --root 폴더    이 폴더 바로 아래 레포도 후보에 넣는다 (--all)
   --detail       프로젝트별 상세 표도 출력 (--all)
   --only a,b     등록한 프로젝트 중 선택 (이름 또는 ID)
+  --no-hooks     setup 에서 훅 설치를 건너뛴다
   --yes          push 확인을 건너뛴다
   --quiet        출력 없이 돈다 (sync)
   --site URL     push 대상 (기본 ${DEFAULT_SITE})
@@ -107,20 +124,34 @@ async function scanMany(o) {
   const out = path.resolve(o.out || process.env.LOSTVIBE_DIR || path.join(os.homedir(), '.lostvibe'));
   fs.mkdirSync(out, { recursive: true });
   const landFile = path.join(out, 'land.json');
-  const prev = readJson(landFile);
-  const prevById = new Map((prev?.projects || []).map((p) => [p.project.id, p.reported]));
+  const prevById = previousReported(out);
   const land = await scanAll({
     extraRoots: o.root,
-    onProgress: progress,
+    onProgress: o.json ? () => {} : progress,
     cacheDir: homeDir(o),
     reportedFor: (id) => prevById.get(id),
   });
   doneProgress();
-  if (o.ask) {
+  if (o.ask && !o.json) {
     for (const p of land.projects) p.reported = await askReported(p.project.name, p.reported);
   }
   const clean = { ...land, projects: land.projects.map(stripLocal) };
   fs.writeFileSync(landFile, `${JSON.stringify(clean, null, 2)}\n`);
+  // The full list with local paths stays on this computer. setup --source / --merge read it.
+  const entries = land.projects.map(scanEntry);
+  const scanFile = path.join(out, 'scan-all.json');
+  saveJson(scanFile, {
+    scanned_at: land.scanned_at,
+    projects: entries.map((e, i) => ({
+      ...e,
+      folder: land.projects[i]._local?.folder || null,
+      cwds: land.projects[i]._local?.cwds || [],
+    })),
+  });
+  if (o.json) {
+    process.stdout.write(`${JSON.stringify({ projects: entries })}\n`);
+    return;
+  }
   console.log(landTable(land));
   if (o.detail) for (const p of land.projects) console.log(projectTable(p));
   console.log(`\n프로젝트 ${land.projects.length}개. 어느 프로젝트에도 속하지 않는 임시 폴더 토큰은 뺐다.`);
@@ -128,6 +159,21 @@ async function scanMany(o) {
   console.log(`저장: ${landFile}`);
 }
 
+// reported answers from the last scan --all and the last sync, sync winning.
+function previousReported(dir) {
+  const map = new Map();
+  for (const f of ['land.json', 'sync-land.json'])
+    for (const p of readJson(path.join(dir, f))?.projects || []) if (p?.project?.id) map.set(p.project.id, p.reported);
+  return map;
+}
+
+function readScanAll(o) {
+  const scan = readJson(path.join(homeDir(o), 'scan-all.json'));
+  if (!scan?.projects) throw new Error('먼저 scan --all 을 실행해 주세요.');
+  return scan.projects;
+}
+const rootsOf = (e) => (e.folder ? [path.dirname(e.folder)] : []);
+
 async function scanOne(o) {
   const dir = path.resolve(o._[1] || '.');
   const file = path.join(dir, 'lostvibe.json');
@@ -263,18 +309,25 @@ async function syncCmd(o) {
     const namespace = sha(`${site}:${token}`);
     const sentFile = path.join(dir, `sent-v4-${namespace}.json`);
     const sent = readJson(sentFile) || {};
-    const prev = readJson(path.join(dir, 'land.json'));
-    const prevById = new Map((prev?.projects || []).map((p) => [p.project.id, p.reported]));
+    const prevById = previousReported(dir);
+    const merge = mergeMap(allowed);
     const land = await scanAll({
-      extraRoots: [...o.root, ...allowed.map((p) => path.dirname(p.cwd))],
+      // Folders without git are placed by their parent folder, so every known parent is a root.
+      extraRoots: [
+        ...o.root,
+        ...allowed.filter((p) => p.cwd).map((p) => path.dirname(p.cwd)),
+        ...allowed.flatMap((p) => p.roots || []),
+      ],
       cacheDir: dir,
-      only: new Set(allowed.map((p) => p.sourceId)),
+      only: new Set([...allowed.map((p) => p.sourceId), ...merge.keys()]),
+      merge,
       onProgress: o.quiet ? () => {} : progress,
       reportedFor: (id) => prevById.get(id),
     });
     doneProgress();
     const clean = { ...land, projects: land.projects.map(stripLocal) };
-    writeAtomic(path.join(dir, 'land.json'), clean);
+    // Kept apart from land.json so a sync never wipes the scan --all result.
+    writeAtomic(path.join(dir, 'sync-land.json'), clean);
     if (!clean.projects.length) {
       if (!o.quiet)
         console.log(
@@ -328,16 +381,31 @@ async function syncCmd(o) {
       const child = spawn(
         process.execPath,
         [process.argv[1], 'worker', '--quiet', '--out', dir, '--site', site, '--project', p.id],
-        { cwd: p.cwd, detached: true, stdio: ['ignore', log, log], windowsHide: true },
+        { cwd: p.cwd && fs.existsSync(p.cwd) ? p.cwd : dir, detached: true, stdio: ['ignore', log, log], windowsHide: true },
       );
       child.unref();
       fs.closeSync(log);
     }
   }
 }
+// The registered project a session folder belongs to: its own id, a merged id, or (without git) a parent folder.
+function linkedFor(cwd, projects) {
+  const target = resolveCwd(cwd);
+  const ids = [projectIdentity(target.repoPath, target.key)];
+  if (!target.repoPath)
+    for (let d = path.dirname(cwd); d !== path.dirname(d) && d !== os.homedir(); d = path.dirname(d))
+      ids.push(projectIdentity(null, `folder:${path.basename(d).toLowerCase()}`));
+  for (const id of ids) {
+    const p = projects.find((x) => x.sourceId === id) || projects.find((x) => (x.merge || []).includes(id));
+    if (p) return p;
+  }
+  return null;
+}
+const STOP_GAP_MS = 10 * 60 * 1000;
 function hookCmd(o) {
   // Detached child survives the short SessionEnd deadline on both clients.
   let cwd = process.cwd();
+  let event = null;
   try {
     const payload = o._[1]
       ? JSON.parse(o._[1])
@@ -345,15 +413,30 @@ function hookCmd(o) {
         ? JSON.parse(fs.readFileSync(0, 'utf8'))
         : {};
     if (payload.cwd && fs.existsSync(payload.cwd)) cwd = payload.cwd;
+    if (typeof payload.hook_event_name === 'string') event = payload.hook_event_name.slice(0, 40);
   } catch {
     /* no notification payload */
   }
-  const target = resolveCwd(cwd);
-  const sourceId = projectIdentity(target.repoPath, target.key);
-  const linked = selectedProjects(o).find((p) => p.sourceId === sourceId);
-  if (!linked) return;
   const dir = homeDir(o);
   fs.mkdirSync(dir, { recursive: true });
+  const from = ['claude', 'codex'].includes(o.from) ? o.from : null;
+  const at = new Date().toISOString();
+  try {
+    const last = readJson(path.join(dir, 'hook-last.json')) || {};
+    const clients = { ...(last.clients || {}), ...(from ? { [from]: { event, at } } : {}) };
+    saveJson(path.join(dir, 'hook-last.json'), { from, event, at, clients });
+  } catch {
+    /* a record must not stop the sync */
+  }
+  const linked = linkedFor(cwd, selectedProjects(o));
+  if (!linked) return;
+  // Stop fires after every turn; one sync per 10 minutes is enough. SessionEnd always syncs.
+  const stamp = path.join(dir, `hook-spawn-${linked.id}`);
+  if (event === 'Stop') {
+    const prev = Number(readJson(stamp)?.at) || 0;
+    if (Date.now() - prev < STOP_GAP_MS) return;
+  }
+  fs.writeFileSync(stamp, JSON.stringify({ at: Date.now() }), { mode: 0o600 });
   const log = fs.openSync(path.join(dir, 'sync.log'), 'a', 0o600);
   const args = [process.argv[1], 'worker', '--quiet', '--project', linked.id];
   if (o.site) args.push('--site', o.site);
@@ -491,20 +574,49 @@ async function pushCmd(o) {
 async function setupCmd(o) {
   const token = savedToken(o);
   if (!token) throw new Error(NO_TOKEN);
+  const ids = (o.merge || '')
+    .split(',')
+    .map((x) => x.trim())
+    .filter(Boolean);
+  // Read the scan list before touching anything, so a wrong id changes nothing.
+  const scan = o.source || ids.length ? readScanAll(o) : [];
+  let entry = null;
+  if (o.source) {
+    entry = scan.find((e) => e.id === o.source);
+    if (!entry) throw new Error('scan --all 목록에 없는 id예요. scan --all --json 을 다시 실행해 확인해 주세요.');
+    if (entry.setup === 'folder' && entry.path)
+      throw new Error(`이 프로젝트는 폴더가 있어요. 그 폴더에서 setup을 실행해 주세요: ${entry.path}`);
+  }
+  const merged = ids.map((id) => {
+    const e = scan.find((x) => x.id === id);
+    if (!e) throw new Error(`scan --all 목록에 없는 id예요: ${id}`);
+    return e;
+  });
   // Validate the account before replacing a saved key.
   await request(siteOf(o), token, '/api/me/connection');
   if (o.token) loginCmd(o);
-  const p = await registerCurrent(o, token);
+  let p = entry
+    ? await registerProject(o, token, { sourceId: entry.id, name: entry.name, cwd: null, roots: rootsOf(entry) })
+    : await registerCurrent(o, token);
+  if (merged.length) {
+    const own = selectedProjects({ ...o, project: undefined, only: undefined });
+    for (const e of merged) {
+      if (e.id === p.sourceId) throw new Error('자기 자신은 합칠 수 없어요.');
+      const other = own.find((x) => x.sourceId === e.id);
+      if (other) throw new Error(`이미 따로 연결한 프로젝트는 합칠 수 없어요: ${other.name}`);
+    }
+    p = setMerge(o, p.sourceId, merged.map((e) => e.id), merged.flatMap(rootsOf));
+    console.log(`합친 프로젝트: ${merged.map((e) => e.name).join(', ')}`);
+  }
   await syncCmd({ ...o, project: p.id });
   if (!o.noHooks) {
     try {
-      const clients = installHooks(o);
-      console.log(`자동 갱신 설정: ${clients.join(', ')}. Codex 훅은 /hooks에서 신뢰 검토 후 실행돼요.`);
+      for (const line of installLines(o, installHooks(o))) console.log(line);
     } catch (e) {
       console.log(`자동 갱신 설정 필요: ${e.message}`);
     }
   }
-  console.log(`프로젝트 연결됨 · 공개 범위는 사이트에서 직접 선택해 주세요. ${siteOf(o)}/?p=${p.id}`);
+  console.log(`프로젝트 연결됨 (id ${p.id}) · 공개 범위는 사이트에서 직접 선택해 주세요. ${siteOf(o)}/?p=${p.id}`);
 }
 async function draftCmd(o) {
   if (!o.file) throw new Error('--file 에 프로젝트 JSON 파일을 지정해 주세요.');
@@ -512,9 +624,17 @@ async function draftCmd(o) {
   if (Buffer.byteLength(source) > 64000) throw new Error('파일은 64KB까지예요.');
   const data = JSON.parse(source);
   if (!data || typeof data !== 'object' || Array.isArray(data)) throw new Error('프로젝트 JSON이 필요해요.');
-  const current = currentIdentity();
-  const p = selectedProjects(o).find((p) => p.sourceId === current.sourceId);
-  if (!p) throw new Error('이 폴더에서 먼저 setup을 실행해 주세요.');
+  const validOf = (v) => Number.isInteger(v) && v >= 1 && v <= 200;
+  let importOf = data.importOf;
+  if (o.of !== undefined) {
+    importOf = /^\d+$/.test(o.of) ? Number(o.of) : NaN;
+    if (!validOf(importOf)) throw new Error('--of 에는 1부터 200까지의 정수를 넣어 주세요.');
+  } else if (importOf !== undefined && !validOf(importOf)) throw new Error('importOf 는 1부터 200까지의 정수예요.');
+  // --project picks a linked project by id from any folder (needed for setup --source projects).
+  const p = o.project
+    ? selectedProjects(o).find((x) => x.id === o.project)
+    : selectedProjects(o).find((x) => x.sourceId === currentIdentity().sourceId);
+  if (!p) throw new Error(o.project ? '연결한 프로젝트 중에 이 id가 없어요.' : '이 폴더에서 먼저 setup을 실행해 주세요.');
   // Never send file-provided publication settings or arbitrary fields.
   const keys = [
     'version',
@@ -537,8 +657,9 @@ async function draftCmd(o) {
     'result2Goal',
   ];
   const safe = Object.fromEntries(keys.filter((k) => k in data).map((k) => [k, data[k]]));
+  if (importOf !== undefined) safe.importOf = importOf;
   await request(siteOf(o), savedToken(o), `/api/me/projects/${p.id}`, 'PATCH', safe);
-  console.log(`비공개 검토 초안을 보냈어요. ${siteOf(o)}/?p=${p.id}`);
+  console.log(`비공개 검토 초안을 보냈어요 (id ${p.id}). ${siteOf(o)}/?p=${p.id}`);
 }
 async function collectorCmd(o) {
   if (o._[1] === 'remove') {
@@ -546,15 +667,19 @@ async function collectorCmd(o) {
     console.log('성과 자동 갱신 연결을 해제했어요.');
     return;
   }
-  if (o._[1] !== 'add') throw new Error('collector add 또는 remove를 지정해 주세요.');
+  if (o._[1] === 'test') {
+    await testCollector(o);
+    return;
+  }
+  if (o._[1] !== 'add') throw new Error('collector add, test 또는 remove를 지정해 주세요.');
+  if (!['result', 'result2'].includes(o.slot)) throw new Error('--slot result 또는 result2가 필요해요.');
   const p = selectedProjects(o).find((p) => p.id === o.project);
   if (!p) throw new Error('먼저 프로젝트를 연결해 주세요.');
+  collectorCwd(p.cwd, o.cwd);
   const info = await request(siteOf(o), savedToken(o), `/api/projects/${p.id}`);
-  if (
-    !['result', 'result2'].includes(o.slot) ||
-    !(info[o.slot]?.name || info.pendingDraft?.[o.slot === 'result' ? 'resultName' : 'result2Name'])
-  )
-    throw new Error('사이트에서 성과를 먼저 저장해 주세요.');
+  const nameKey = o.slot === 'result' ? 'resultName' : 'result2Name';
+  if (!(info[o.slot]?.name || info.pendingDraft?.[nameKey]))
+    throw new Error(`성과 이름이 아직 없어요. project.json에 ${nameKey}을 넣고 draft를 먼저 실행해 주세요.`);
   const previous = process.cwd();
   try {
     process.chdir(p.cwd);
@@ -567,10 +692,12 @@ async function collectorCmd(o) {
 }
 async function workerCmd(o) {
   let failed = false;
+  let recordsOk = true;
   try {
     await syncCmd(o);
   } catch {
     failed = true;
+    recordsOk = false;
     console.error(`${new Date().toISOString()} 작업 기록 갱신 실패`);
     for (const p of selectedProjects(o)) await sendStatus(siteOf(o), savedToken(o), p.id, 'records', false);
   }
@@ -581,6 +708,14 @@ async function workerCmd(o) {
     console.error(`${new Date().toISOString()} 성과 갱신 실패 · 이전 값 유지`);
   }
   console.log(`${new Date().toISOString()} 자동 갱신 ${failed ? '일부 실패' : '완료'}`);
+  try {
+    const file = path.join(homeDir(o), 'last-sync.json');
+    const at = new Date().toISOString();
+    // lastOkAt: the last time records reached the site.
+    saveJson(file, { at, ok: !failed, lastOkAt: recordsOk ? at : readJson(file)?.lastOkAt || null });
+  } catch {
+    /* status file only */
+  }
   if (failed) process.exitCode = 1;
 }
 
@@ -601,26 +736,12 @@ try {
   else if (cmd === 'collector') await collectorCmd(o);
   else if (cmd === 'worker') await workerCmd(o);
   else if (cmd === 'hooks') {
-    if (o._[1] === 'install')
-      console.log(
-        `설치됨: ${installHooks(o).join(', ')}. Codex는 /hooks에서 신뢰 검토가 필요해요. 실제 이벤트 검증 전에는 연결 완료로 보지 마세요.`,
-      );
+    if (o._[1] === 'install') for (const line of installLines(o, installHooks(o))) console.log(line);
     else if (o._[1] === 'remove') {
       removeHooks(o);
-      console.log('Lostvibe 훅만 제거했어요.');
-    } else if (o._[1] === 'status') {
-      const entries = hookStatus(o);
-      console.log(
-        entries.length
-          ? entries
-              .map(
-                (e) =>
-                  `${e.client} ${e.event}: ${e.installed ? '설정 있음 (클라이언트 신뢰·실행 확인 필요)' : '설정 없음'}`,
-              )
-              .join('\n')
-          : '설치된 훅 없음',
-      );
-    } else throw new Error('hooks install / status / remove');
+      console.log('Lostvibe 훅만 제거했어요. 다른 훅은 그대로예요.');
+    } else if (o._[1] === 'status') for (const line of statusLines(hookStatus(o))) console.log(line);
+    else throw new Error('hooks install / status / remove');
   } else {
     console.log(HELP);
     process.exit(1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lostvibe",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "프로젝트의 객관 지표를 로컬 로그와 git에서 읽는 CLI. 코드와 대화 내용은 보내지 않는다.",
   "keywords": [
     "lostvibe",

package/src/collectors.mjs

@@ -37,6 +37,23 @@ export function parseCollected(source) {
       `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}`,
   };
 }
+// A collector cwd is stored relative to the project folder and must stay inside it.
+export function collectorCwd(projectDir, dir) {
+  if (!projectDir) throw new Error('폴더가 없는 프로젝트에는 성과 명령을 연결할 수 없어요.');
+  if (!dir) return '.';
+  let base, target;
+  try {
+    base = fs.realpathSync(projectDir);
+    target = fs.realpathSync(path.resolve(dir));
+  } catch {
+    throw new Error('--cwd 폴더를 찾지 못했어요.');
+  }
+  if (!fs.statSync(target).isDirectory()) throw new Error('--cwd 에는 폴더를 지정해 주세요.');
+  const rel = path.relative(base, target);
+  if (rel.startsWith('..') || path.isAbsolute(rel)) throw new Error('--cwd 는 프로젝트 폴더 안이어야 해요.');
+  return rel || '.';
+}
+const cwdOf = (p, c) => (c.cwd && path.isAbsolute(c.cwd) ? c.cwd : path.join(p.cwd, c.cwd || '.'));
 export function addCollector(o) {
   if (!['result', 'result2'].includes(o.slot)) throw new Error('--slot result 또는 result2가 필요해요.');
   let raw;
@@ -51,7 +68,7 @@ export function addCollector(o) {
   if (!p) throw new Error('먼저 이 프로젝트를 setup으로 연결해 주세요.');
   // Store only an explicitly registered command in user state. Never execute imported/repository config.
   p.collectors ||= {};
-  p.collectors[o.slot] = { command, cwd: p.cwd };
+  p.collectors[o.slot] = { command, cwd: collectorCwd(p.cwd, o.cwd) };
   saveJson(path.join(dir, 'connections.json'), state);
 }
 export function removeCollector(o) {
@@ -61,6 +78,27 @@ export function removeCollector(o) {
   delete p.collectors?.[o.slot];
   saveJson(path.join(dir, 'connections.json'), state);
 }
+// Failure categories only. stderr and stdout are never printed: they may hold secrets.
+export function classifyFailure({ code, signal, killed, stderr = '' } = {}) {
+  const err = String(stderr);
+  if (code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER') return 'JSON 형식 오류';
+  if (killed || signal === 'SIGTERM' || code === 'ETIMEDOUT') return '시간 초과';
+  if (code === 'ENOENT' || /cannot find module|err_module_not_found|modulenotfounderror|no module named|command not found|cannot find package/i.test(err))
+    return '모듈을 찾지 못함';
+  if (/no such table|relation "?[^"\s]*"? does not exist|table '?[^'\s]*'? doesn't exist|undefined_table|42P01|PGRST205|could not find the table/i.test(err))
+    return '테이블 없음';
+  if (/environment variable|env(ironment)? var|\bis not set\b|is not defined in env|missing required env|keyerror: ['"][A-Z][A-Z0-9_]*['"]|process\.env\.[A-Z_]+ is (undefined|missing)|\b[A-Z][A-Z0-9]*_(URL|KEY|TOKEN|SECRET|DSN)\b.*(missing|required|undefined|not (set|found|defined))/i.test(err))
+    return '환경 변수 없음';
+  if (/ECONNREFUSED|ENOTFOUND|EAI_AGAIN|ECONNRESET|ETIMEDOUT|getaddrinfo|could not connect|connection (refused|terminated|failed|error)|password authentication failed|authentication failed|too many connections|SQLITE_CANTOPEN|unable to open database|database .* does not exist|fetch failed|server closed the connection/i.test(err))
+    return 'DB 연결 실패';
+  return '알 수 없는 오류';
+}
+class CollectorError extends Error {
+  constructor(kind) {
+    super(`성과 조회 명령이 실패했어요 (${kind}). 이전 값을 유지해요.`);
+    this.kind = kind;
+  }
+}
 async function run(command, cwd) {
   const env = { ...process.env };
   for (const k of ['LOSTVIBE_TOKEN', 'LOSTVIBE_METRICS_TOKEN']) delete env[k];
@@ -69,11 +107,42 @@ async function run(command, cwd) {
       command[0],
       command.slice(1),
       { cwd, env, timeout: 20000, maxBuffer: 64_000, windowsHide: true },
-      (e, stdout) =>
-        e ? reject(new Error('성과 조회 명령이 실패했어요. 이전 값을 유지해요.')) : resolve(stdout),
+      (e, stdout, stderr) =>
+        e
+          ? reject(new CollectorError(classifyFailure({ code: e.code, signal: e.signal, killed: e.killed, stderr })))
+          : resolve(stdout),
     ),
   );
 }
+// Runs a collector the way collect does and returns { value, date } or throws with .kind.
+export async function runCollector(command, cwd) {
+  const out = await run(validateCommand(command), cwd);
+  try {
+    return parseCollected(out);
+  } catch {
+    throw new CollectorError('JSON 형식 오류');
+  }
+}
+export async function testCollector(o) {
+  let raw;
+  try {
+    raw = JSON.parse(o.commandJson);
+  } catch {
+    throw new Error('--command-json 에 명령 배열이 필요해요.');
+  }
+  const command = validateCommand(raw);
+  const p = o.project ? selectedProjects(o).find((x) => x.id === o.project) : null;
+  if (o.project && !p) throw new Error('먼저 이 프로젝트를 setup으로 연결해 주세요.');
+  const base = p?.cwd || process.cwd();
+  const cwd = o.cwd ? path.join(base, collectorCwd(base, o.cwd)) : base;
+  try {
+    const sample = await runCollector(command, cwd);
+    console.log(`값: ${sample.value} (${sample.date})`);
+  } catch (e) {
+    console.error(`실패: ${e.kind || '알 수 없는 오류'}`);
+    process.exitCode = 1;
+  }
+}
 export async function collect(o, token) {
   const site = siteOf(o),
     { dir } = activeConnection(o);
@@ -84,7 +153,7 @@ export async function collect(o, token) {
   const skipped = new Set((connection.skipped || []).map((p) => p.sourceId));
   let failed = 0;
   for (const p of selected.filter((p) => ids.has(p.id) && !skipped.has(p.sourceId))) {
-    if (!Object.keys(p.collectors || {}).length) continue;
+    if (!p.cwd || !Object.keys(p.collectors || {}).length) continue;
     const current = await request(site, token, `/api/projects/${p.id}`);
     for (const [slot, c] of Object.entries(p.collectors || {})) {
       if (!current[slot]?.name) continue;
@@ -106,7 +175,7 @@ export async function collect(o, token) {
         continue;
       }
       try {
-        const sample = parseCollected(await run(validateCommand(c.command), c.cwd));
+        const sample = await runCollector(c.command, cwdOf(p, c));
         const tokenFile = path.join(p.cwd, '.lostvibe', `metrics-token-${p.id}`);
         const scoped = fs.readFileSync(tokenFile, 'utf8').trim();
         const result = await request(site, scoped, `/api/me/projects/${p.id}/metrics`, 'POST', {

package/src/connections.mjs

@@ -2,7 +2,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { resolveCwd, projectIdentity, sha } from './gitinfo.mjs';
-export const VERSION = '0.7.0';
+export const VERSION = '0.8.0';
 export const stateDir = (o = {}) =>
   path.resolve(o.out || process.env.LOSTVIBE_DIR || path.join(os.homedir(), '.lostvibe'));
 export function readState(dir) {
@@ -24,10 +24,12 @@ export function activeConnection(o = {}) {
   const account = state.accounts?.[state.active];
   return { dir, state, account };
 }
-export function currentIdentity() {
-  const r = resolveCwd(process.cwd());
-  if (!r.repoPath) throw new Error('프로젝트의 git 폴더에서 실행해 주세요.');
-  return { ...r, sourceId: projectIdentity(r.repoPath, r.key) };
+// A folder without git is the project `folder:<name>`, the same key scan --all gives it.
+export function currentIdentity(cwd = process.cwd()) {
+  const r = resolveCwd(cwd);
+  if (r.repoPath) return { ...r, cwd: r.repoPath, sourceId: projectIdentity(r.repoPath, r.key) };
+  if (cwd === os.homedir() || cwd === path.dirname(cwd)) throw new Error('프로젝트 폴더 안에서 실행해 주세요.');
+  return { ...r, cwd, sourceId: projectIdentity(null, r.key) };
 }
 export function siteOf(o = {}) {
   const { account } = activeConnection(o);
@@ -66,13 +68,17 @@ export async function request(site, token, url, method = 'GET', body) {
   return d;
 }
 export async function registerCurrent(o, token) {
+  const current = currentIdentity();
+  return registerProject(o, token, { sourceId: current.sourceId, name: current.name, cwd: current.cwd });
+}
+// ident: { sourceId, name, cwd (null for a project known only from logs), roots? }
+export async function registerProject(o, token, current) {
   const dir = stateDir(o),
     site = siteOf(o),
     connection = await request(site, token, '/api/me/connection');
-  const current = currentIdentity();
   const existing = connection.projects.find((p) => p.sourceId === current.sourceId);
   if (o.project && (!existing || existing.id !== o.project))
-    throw new Error('선택한 프로젝트와 현재 git 폴더가 달라요. 올바른 폴더에서 다시 실행해 주세요.');
+    throw new Error('선택한 프로젝트와 현재 폴더가 달라요. 올바른 폴더에서 다시 실행해 주세요.');
   if (connection.skipped?.some((p) => p.sourceId === current.sourceId))
     throw new Error('넘긴 프로젝트예요. 사이트에서 다시 가져온 뒤 연결해 주세요.');
   const target =
@@ -86,17 +92,37 @@ export async function registerCurrent(o, token) {
   state.accounts ||= {};
   state.accounts[key] ||= { site, login: connection.login, projects: {} };
   const account = state.accounts[key];
+  const prev = account.projects[current.sourceId] || {};
+  const roots = [...new Set([...(prev.roots || []), ...(current.roots || [])])];
   account.projects[current.sourceId] = {
-    ...account.projects[current.sourceId],
+    ...prev,
     sourceId: current.sourceId,
     id: target.id,
-    cwd: current.repoPath,
+    cwd: current.cwd || null,
     name: current.name,
+    ...(roots.length ? { roots } : {}),
   };
   state.active = key;
   saveJson(path.join(dir, 'connections.json'), state);
   return account.projects[current.sourceId];
 }
+// Other scan ids whose logs count as this project's. roots are workspaces that place their folders.
+export function setMerge(o, sourceId, ids, roots = []) {
+  const { dir, state, account } = activeConnection(o);
+  const p = account?.projects?.[sourceId];
+  if (!p) throw new Error('먼저 이 프로젝트를 setup으로 연결해 주세요.');
+  p.merge = [...new Set([...(p.merge || []), ...ids])].filter((id) => id !== sourceId);
+  const all = [...new Set([...(p.roots || []), ...roots])];
+  if (all.length) p.roots = all;
+  saveJson(path.join(dir, 'connections.json'), state);
+  return p;
+}
+// other sourceId -> main sourceId, for scanAll({ merge }).
+export function mergeMap(projects) {
+  const map = new Map();
+  for (const p of projects) for (const id of p.merge || []) if (id !== p.sourceId) map.set(id, p.sourceId);
+  return map;
+}
 export function selectedProjects(o = {}) {
   const { account } = activeConnection(o);
   if (!account) return [];

package/src/hooks.mjs

@@ -1,9 +1,18 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-import { VERSION, stateDir, saveJson } from './connections.mjs';
+import { stateDir, saveJson } from './connections.mjs';
+
 const quote = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+// Any hook that runs `lostvibe.mjs hook` is ours, whichever version or folder installed it.
+export const OUR_HOOK = /lostvibe\.mjs'?\s+hook\b/;
+const isOurs = (h) => typeof h?.command === 'string' && OUR_HOOK.test(h.command);
+const EVENTS = ['Stop', 'SessionEnd'];
+const TEMP = /(^|['"\s])\/(private\/)?tmp\//;
+const snake = (e) => e.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+
 function load(file, fallback = {}) {
   if (!fs.existsSync(file)) return fallback;
   const data = JSON.parse(fs.readFileSync(file, 'utf8'));
@@ -11,88 +20,319 @@ function load(file, fallback = {}) {
     throw new Error(`설정 형식을 읽지 못했어요: ${path.basename(file)}`);
   return data;
 }
-function targets() {
-  const list = [];
+function readSafe(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function clients(o = {}) {
   const claude = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
   const codex = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
-  if (fs.existsSync(claude))
-    list.push({ client: 'Claude Code', file: path.join(claude, 'settings.json'), event: 'SessionEnd' });
-  if (fs.existsSync(codex))
-    for (const event of ['Stop', 'SessionEnd'])
-      list.push({ client: 'Codex', file: path.join(codex, 'hooks.json'), event });
-  return list;
-}
-function ownGroups(config, event, command, remove = false) {
-  config.hooks ||= {};
-  const groups = config.hooks[event] || [];
-  if (!Array.isArray(groups)) throw new Error('기존 훅 형식을 읽지 못했어요. 변경하지 않았어요.');
-  if (remove) {
-    config.hooks[event] = groups
-      .map((g) => ({ ...g, hooks: (g.hooks || []).filter((h) => h.command !== command) }))
-      .filter((g) => g.hooks.length);
-    if (!config.hooks[event].length) delete config.hooks[event];
-  } else if (!groups.some((g) => g.hooks?.some((h) => h.command === command))) {
-    config.hooks[event] = [...groups, { hooks: [{ type: 'command', command, timeout: 10 }] }];
+  const want = o.client?.toLowerCase();
+  return [
+    { client: 'Claude Code', from: 'claude', dir: claude, file: path.join(claude, 'settings.json') },
+    { client: 'Codex', from: 'codex', dir: codex, file: path.join(codex, 'hooks.json') },
+  ].filter((c) => !want || c.from === want || c.client.toLowerCase().startsWith(want));
+}
+
+// Removes our hooks from the given events (or every event) and leaves all other hooks as they are.
+function stripOurs(config, events) {
+  if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) {
+    if (events && config.hooks !== undefined) throw new Error('기존 훅 형식을 읽지 못했어요. 변경하지 않았어요.');
+    return false;
+  }
+  let changed = false;
+  for (const event of events || Object.keys(config.hooks)) {
+    const groups = config.hooks[event];
+    if (groups === undefined) continue;
+    if (!Array.isArray(groups)) {
+      if (events) throw new Error('기존 훅 형식을 읽지 못했어요. 변경하지 않았어요.');
+      continue;
+    }
+    const next = [];
+    for (const g of groups) {
+      if (!Array.isArray(g?.hooks) || !g.hooks.some(isOurs)) {
+        next.push(g);
+        continue;
+      }
+      changed = true;
+      const rest = g.hooks.filter((h) => !isOurs(h));
+      if (rest.length) next.push({ ...g, hooks: rest });
+    }
+    if (next.length) config.hooks[event] = next;
+    else if (groups.length) delete config.hooks[event];
   }
-  return config;
+  if (changed && !Object.keys(config.hooks).length) delete config.hooks;
+  return changed;
 }
-export function installHooks(o) {
-  const dir = stateDir(o),
-    chosen = targets().filter((t) => !o.client || t.client.toLowerCase().startsWith(o.client.toLowerCase()));
-  if (!chosen.length) throw new Error('연결할 Claude Code 또는 Codex 설정 폴더를 찾지 못했어요.');
+function findOurs(config, event) {
+  const groups = config.hooks?.[event];
+  if (!Array.isArray(groups)) return null;
+  for (let gi = 0; gi < groups.length; gi++) {
+    const hooks = groups[gi]?.hooks;
+    if (!Array.isArray(hooks)) continue;
+    for (let hi = 0; hi < hooks.length; hi++) if (isOurs(hooks[hi])) return { gi, hi, command: hooks[hi].command };
+  }
+  return null;
+}
+function ourCommands(config) {
+  const out = [];
+  for (const groups of Object.values(config.hooks || {}))
+    if (Array.isArray(groups))
+      for (const g of groups) for (const h of Array.isArray(g?.hooks) ? g.hooks : []) if (isOurs(h)) out.push(h.command);
+  return out;
+}
+
+// A node path that survives node upgrades (e.g. /opt/homebrew/bin/node instead of the Cellar path).
+function stableNode() {
+  let real;
+  try {
+    real = fs.realpathSync(process.execPath);
+  } catch {
+    return process.execPath;
+  }
+  for (const d of (process.env.PATH || '').split(path.delimiter)) {
+    if (!d || !path.isAbsolute(d) || TEMP.test(d) || d.includes('/var/folders/') || d.includes('node_modules')) continue;
+    const c = path.join(d, process.platform === 'win32' ? 'node.exe' : 'node');
+    try {
+      if (fs.realpathSync(c) === real) return c;
+    } catch {
+      /* not here */
+    }
+  }
+  return process.execPath;
+}
+// The hook always runs runtime/current, so its command (and Codex's trust hash) stays the same across versions.
+function installRuntime(dir) {
   const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
-  const runtime = path.join(dir, 'runtime', VERSION);
-  fs.mkdirSync(runtime, { recursive: true });
-  for (const part of ['src', 'bin'])
-    if (path.resolve(packageRoot) !== path.resolve(runtime))
-      fs.cpSync(path.join(packageRoot, part), path.join(runtime, part), { recursive: true });
-  const command = `${quote(process.execPath)} ${quote(path.join(runtime, 'bin', 'lostvibe.mjs'))} hook --out ${quote(dir)}`;
-  const registryFile = path.join(dir, 'hooks.json');
-  const registry = load(registryFile, { entries: [] });
-  // Validate all files before changing any. Keep other hooks and notify untouched.
-  const configs = new Map();
-  for (const t of chosen) if (!configs.has(t.file)) configs.set(t.file, load(t.file));
-  for (const t of chosen) {
-    const config = configs.get(t.file);
-    for (const old of registry.entries.filter((e) => e.file === t.file && e.event === t.event))
-      ownGroups(config, t.event, old.command, true);
-    ownGroups(config, t.event, command);
+  const base = path.join(dir, 'runtime');
+  const current = path.join(base, 'current');
+  if (path.resolve(packageRoot) === path.resolve(current)) return current;
+  const next = path.join(base, `.next-${process.pid}`);
+  fs.rmSync(next, { recursive: true, force: true });
+  fs.mkdirSync(next, { recursive: true });
+  for (const part of ['src', 'bin']) fs.cpSync(path.join(packageRoot, part), path.join(next, part), { recursive: true });
+  fs.copyFileSync(path.join(packageRoot, 'package.json'), path.join(next, 'package.json'));
+  fs.rmSync(current, { recursive: true, force: true });
+  fs.renameSync(next, current);
+  return current;
+}
+export function hookCommand(o, from) {
+  const dir = stateDir(o);
+  return `${quote(stableNode())} ${quote(path.join(dir, 'runtime', 'current', 'bin', 'lostvibe.mjs'))} hook --from ${from} --out ${quote(dir)}`;
+}
+
+// Codex keeps approvals in config.toml as [hooks.state."<hooks.json>:<event>:<group>:<hook>"] trusted_hash = "...".
+// Read only: approval is the user's step inside Codex.
+export function codexTrust(codexDir) {
+  let text;
+  try {
+    text = fs.readFileSync(path.join(codexDir, 'config.toml'), 'utf8');
+  } catch {
+    return new Map();
+  }
+  const unq = (s) => s.replace(/\\(.)/g, '$1');
+  const map = new Map();
+  let key = null;
+  let section = null;
+  for (const line of text.split(/\r?\n/)) {
+    const h = line.match(/^\s*\[\s*hooks\s*\.\s*state\s*\.\s*(?:"((?:[^"\\]|\\.)*)"|'([^']*)')\s*\]/);
+    if (h) {
+      key = h[1] !== undefined ? unq(h[1]) : h[2];
+      section = null;
+      continue;
+    }
+    const s = line.match(/^\s*\[\s*([^\]]+?)\s*\]/);
+    if (s) {
+      key = null;
+      section = s[1].replace(/\s/g, '');
+      continue;
+    }
+    if (key) {
+      const t = line.match(/^\s*trusted_hash\s*=\s*["']([^"']*)["']/);
+      if (t) map.set(key, t[1]);
+    } else if (section === 'hooks.state') {
+      const t = line.match(/^\s*"((?:[^"\\]|\\.)*)"\s*=\s*\{[^}]*trusted_hash\s*=\s*"([^"]*)"/);
+      if (t) map.set(unq(t[1]), t[2]);
+    }
+  }
+  return map;
+}
+const trustKey = (file, event, pos) => `${file}:${snake(event)}:${pos.gi}:${pos.hi}`;
+
+export function codexCli() {
+  try {
+    const found = execFileSync('/bin/sh', ['-c', 'command -v codex'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 5000,
+    }).trim();
+    if (found) return found;
+  } catch {
+    /* not on PATH */
+  }
+  for (const p of [
+    '/Applications/ChatGPT.app/Contents/Resources/codex-cli/bin/codex',
+    '/Applications/Codex.app/Contents/Resources/codex',
+  ])
+    if (fs.existsSync(p)) return p;
+  return null;
+}
+export function codexHint(cli = codexCli()) {
+  return cli
+    ? `Codex 승인: 터미널에서 '${cli}' 실행 → /hooks → Lost Vibe 항목 2개만 Trust`
+    : 'Codex 승인: Codex CLI를 찾지 못했어요. Codex를 열고 /hooks → Lost Vibe 항목 2개만 Trust';
+}
+
+export function installHooks(o = {}) {
+  const dir = stateDir(o);
+  const chosen = clients(o).filter((c) => fs.existsSync(c.dir));
+  if (!chosen.length) throw new Error('연결할 Claude Code 또는 Codex 설정 폴더를 찾지 못했어요.');
+  // Validate all files before changing any.
+  const plans = chosen.map((c) => {
+    const config = load(c.file);
+    return { ...c, before: structuredClone(config), config, command: hookCommand(o, c.from) };
+  });
+  for (const p of plans) {
+    stripOurs(p.config, EVENTS);
+    p.config.hooks ||= {};
+    for (const event of EVENTS)
+      p.config.hooks[event] = [...(p.config.hooks[event] || []), { hooks: [{ type: 'command', command: p.command, timeout: 10 }] }];
   }
-  for (const [file, config] of configs) {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    if (fs.existsSync(file) && !fs.existsSync(file + '.lostvibe-backup'))
-      fs.copyFileSync(file, file + '.lostvibe-backup');
-    saveJson(file, config);
+  installRuntime(dir);
+  const entries = [];
+  for (const p of plans) {
+    fs.mkdirSync(path.dirname(p.file), { recursive: true });
+    if (fs.existsSync(p.file) && !fs.existsSync(p.file + '.lostvibe-backup'))
+      fs.copyFileSync(p.file, p.file + '.lostvibe-backup');
+    saveJson(p.file, p.config);
+    const trust = p.from === 'codex' ? codexTrust(p.dir) : null;
+    for (const event of EVENTS) {
+      const entry = { client: p.client, from: p.from, file: p.file, event, command: p.command };
+      if (trust) {
+        // Remembers the approval that existed at this position so a stale one is not read as approval later.
+        const pos = findOurs(p.config, event);
+        entry.trustKey = trustKey(p.file, event, pos);
+        entry.preHash = trust.get(entry.trustKey) || null;
+        entry.sameCommand = p.before.hooks?.[event]?.[pos.gi]?.hooks?.[pos.hi]?.command === p.command;
+      }
+      entries.push(entry);
+    }
+  }
+  const registryFile = path.join(dir, 'hooks.json');
+  let registry;
+  try {
+    registry = load(registryFile, { entries: [] });
+  } catch {
+    registry = { entries: [] };
   }
   registry.entries = [
-    ...registry.entries.filter((e) => !chosen.some((t) => t.file === e.file && t.event === e.event)),
-    ...chosen.map((t) => ({ ...t, command })),
+    ...(registry.entries || []).filter((e) => !plans.some((p) => p.file === e.file)),
+    ...entries,
   ];
   saveJson(registryFile, registry);
-  return [...new Set(chosen.map((t) => t.client))];
+  return [...new Set(chosen.map((c) => c.client))];
 }
-export function removeHooks(o) {
+
+export function removeHooks(o = {}) {
   const file = path.join(stateDir(o), 'hooks.json');
-  const registry = load(file, { entries: [] });
-  const keep = [];
-  for (const e of registry.entries) {
-    if (o.client && !e.client.toLowerCase().startsWith(o.client.toLowerCase())) {
-      keep.push(e);
-      continue;
+  let registry;
+  try {
+    registry = load(file, { entries: [] });
+  } catch {
+    registry = { entries: [] };
+  }
+  const chosen = clients(o);
+  const files = new Set(chosen.map((c) => c.file));
+  const matches = (e) => !o.client || chosen.some((c) => c.client === e.client);
+  for (const e of registry.entries || []) if (matches(e)) files.add(e.file);
+  for (const f of files) {
+    if (!fs.existsSync(f)) continue;
+    const config = load(f);
+    if (stripOurs(config)) saveJson(f, config);
+  }
+  registry.entries = (registry.entries || []).filter((e) => !matches(e));
+  saveJson(file, registry);
+}
+
+const when = (iso) => {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return '-';
+  const z = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${z(d.getMonth() + 1)}-${z(d.getDate())} ${z(d.getHours())}:${z(d.getMinutes())}`;
+};
+
+// Per client: 미설치 / 설치됨·승인 전 / 승인됨·실행 기록 없음 / 실행됨.
+export function hookStatus(o = {}) {
+  const dir = stateDir(o);
+  const registry = readSafe(path.join(dir, 'hooks.json')) || { entries: [] };
+  const last = readSafe(path.join(dir, 'hook-last.json')) || {};
+  const sync = readSafe(path.join(dir, 'last-sync.json'));
+  const lastSync = sync ? (sync.ok ? sync.at : sync.lastOkAt) || null : null;
+  const out = [];
+  for (const c of clients(o)) {
+    if (!fs.existsSync(c.dir)) continue;
+    let config = {};
+    try {
+      config = load(c.file);
+    } catch {
+      /* unreadable config reads as not installed */
     }
-    if (fs.existsSync(e.file)) {
-      const c = load(e.file);
-      saveJson(e.file, ownGroups(c, e.event, e.command, true));
+    const positions = EVENTS.map((event) => ({ event, pos: findOurs(config, event) }));
+    const installed = positions.every((p) => p.pos);
+    let approved = installed;
+    if (installed && c.from === 'codex') {
+      const trust = codexTrust(c.dir);
+      approved = positions.every(({ event, pos }) => {
+        const key = trustKey(c.file, event, pos);
+        const hash = trust.get(key);
+        if (!hash) return false;
+        const snap = (registry.entries || []).find((e) => e.trustKey === key && e.command === pos.command);
+        return !(snap && snap.preHash && snap.preHash === hash && !snap.sameCommand);
+      });
     }
+    const lastRun = last.clients?.[c.from]?.at || (last.from === c.from ? last.at : null) || null;
+    const state = !installed
+      ? '미설치'
+      : !approved
+        ? '설치됨·승인 전'
+        : !lastRun
+          ? '승인됨·실행 기록 없음'
+          : '실행됨';
+    out.push({
+      client: c.client,
+      from: c.from,
+      state,
+      installed,
+      approved,
+      lastRun,
+      lastSync,
+      temp: ourCommands(config).some((cmd) => TEMP.test(cmd)),
+    });
   }
-  registry.entries = keep;
-  saveJson(file, registry);
+  return out;
+}
+export function statusLines(entries, cli) {
+  if (!entries.length) return ['Claude Code와 Codex 설정 폴더를 찾지 못했어요.'];
+  const lines = entries.map((e) =>
+    e.state === '실행됨'
+      ? `${e.client}: 실행됨 (마지막 실행 ${when(e.lastRun)}, 마지막 사이트 반영 ${e.lastSync ? when(e.lastSync) : '없음'})`
+      : `${e.client}: ${e.state}`,
+  );
+  if (entries.some((e) => e.from === 'codex' && e.installed && !e.approved)) lines.push(codexHint(cli));
+  if (entries.some((e) => e.temp))
+    lines.push('주의: 임시 폴더(/tmp)를 가리키는 Lost Vibe 훅이 있어요. hooks install을 다시 실행하면 정리돼요.');
+  return lines;
 }
-export function hookStatus(o) {
-  const registry = load(path.join(stateDir(o), 'hooks.json'), { entries: [] });
-  return registry.entries.map((e) => ({
-    ...e,
-    installed:
-      load(e.file).hooks?.[e.event]?.some((g) => g.hooks?.some((h) => h.command === e.command)) || false,
-  }));
+// What install did and what is left for the user.
+export function installLines(o, installed, cli) {
+  const lines = [`자동 갱신 훅을 설치했어요: ${installed.join(', ')} (Stop, SessionEnd).`];
+  const entries = hookStatus(o).filter((e) => installed.includes(e.client));
+  const pending = entries.some((e) => e.from === 'codex' && !e.approved);
+  if (installed.includes('Claude Code')) lines.push('Claude Code는 승인이 필요 없어요. 다음 세션부터 자동으로 갱신돼요.');
+  if (pending) lines.push(`남은 일: ${codexHint(cli)}`);
+  else if (installed.includes('Codex')) lines.push('Codex는 이미 승인돼 있어요.');
+  return lines;
 }

package/src/scan.mjs

@@ -30,7 +30,7 @@ function folderProject(cwd, workspaces, repoNames) {
     // A leftover copy or worktree folder such as app-backup belongs to app.
     const base = COPY_SUFFIX.test(lower) ? lower.replace(COPY_SUFFIX, '') : null;
     if (base && repoNames.has(base)) return repoNames.get(base);
-    return { key: `folder:${lower}`, name, repoPath: null, remote: null };
+    return { key: `folder:${lower}`, name, repoPath: null, remote: null, folder: path.join(w, name) };
   }
   return null;
 }
@@ -81,7 +81,25 @@ function deviceZone(dir) {
   return zone;
 }
 
-export async function scanAll({ extraRoots = [], onProgress = () => {}, reportedFor = () => null, cacheDir = null, only = null } = {}) {
+// Groups named in merge (other id -> main id) join the main group before totals are computed.
+// When the main group is missing, the first group merged into it takes its place.
+export function foldGroups(groups, merge) {
+  if (!merge?.size) return groups;
+  const byId = new Map(groups.map((g) => [g.id, g]));
+  const out = [];
+  for (const g of groups) {
+    const mainId = merge.get(g.id);
+    if (!mainId || mainId === g.id || merge.has(mainId)) { out.push(g); continue; }
+    const main = byId.get(mainId);
+    if (!main || main === g) { g.id = mainId; byId.set(mainId, g); out.push(g); continue; }
+    main.buckets.push(...g.buckets);
+    main.cwds.push(...g.cwds);
+    if (!main.folder && g.folder) main.folder = g.folder;
+  }
+  return out;
+}
+
+export async function scanAll({ extraRoots = [], onProgress = () => {}, reportedFor = () => null, cacheDir = null, only = null, merge = null } = {}) {
   setZone(deviceZone(cacheDir));
   const cacheFile = cacheDir ? path.join(cacheDir, 'log-cache-v2.json') : null;
   const cache = (cacheFile && readJson(cacheFile)) || { files: {} };
@@ -117,6 +135,7 @@ export async function scanAll({ extraRoots = [], onProgress = () => {}, reported
     if (!groups.has(r.key)) groups.set(r.key, { key: r.key, remote: r.remote, name: r.name, repos: new Set(), buckets: [], cwds: [] });
     const g = groups.get(r.key);
     if (r.repoPath) g.repos.add(r.repoPath);
+    if (r.folder && !g.folder) g.folder = r.folder;
     g.buckets.push(buckets.get(cwd));
     g.cwds.push(cwd);
   };
@@ -152,14 +171,20 @@ export async function scanAll({ extraRoots = [], onProgress = () => {}, reported
     groups.get(r.key).repos.add(r.repoPath);
   }
 
+  // Every group's id is known before merging, so merged groups fold by id and only filters by id.
+  for (const g of groups.values()) {
+    const repos = [...g.repos];
+    g.repo = repos.length > 1 ? repos.map((p) => [p, commitCount(p)]).sort((a, b) => b[1] - a[1])[0][0] : repos[0] || null;
+    g.id = projectIdentity(g.repo, g.key);
+  }
   const projects = [];
-  const list = [...groups.values()].filter((g) => !only || only.has(g.name.toLowerCase()) || [...g.repos].some((p) => only.has(path.basename(p).toLowerCase())) || only.has(projectIdentity([...g.repos][0] || null,g.key)));
+  const list = foldGroups([...groups.values()], merge).filter((g) => !only || only.has(g.id) || only.has(g.name.toLowerCase()) || [...g.repos].some((p) => only.has(path.basename(p).toLowerCase())));
   for (let i = 0; i < list.length; i++) {
     const g = list[i];
     onProgress(`프로젝트 ${i + 1}/${list.length}: ${g.name}`);
-    const repo = [...g.repos].map((p) => [p, commitCount(p)]).sort((a, b) => b[1] - a[1])[0]?.[0] || null;
+    const repo = g.repo;
     const name = repo ? path.basename(repo) : g.name;
-    const id = projectIdentity(repo, g.key);
+    const id = g.id;
     const merged = mergeBuckets(g.buckets);
     const slug = githubSlug(g.remote);
     const gh = process.env.LOSTVIBE_SKIP_REMOTE === '1' ? null : await readGithub(slug.owner, slug.repo);
@@ -189,7 +214,9 @@ export async function scanAll({ extraRoots = [], onProgress = () => {}, reported
       usage_days: usageDays(merged),
       sessions: merged.sessions.size,
     });
-    projects[projects.length - 1]._local = { repo, cwds: g.cwds };
+    const folder = g.folder && fs.existsSync(g.folder) ? g.folder : null;
+    const local = repo || folder || g.cwds.find((c) => fs.existsSync(c)) || null;
+    projects[projects.length - 1]._local = { repo, cwds: g.cwds, folder: g.folder || null, path: local, exists: !!local, git: !!repo };
   }
   projects.sort((a, b) => (b.verified.ai?.tokens.total || 0) - (a.verified.ai?.tokens.total || 0) || (b.verified.git?.commits || 0) - (a.verified.git?.commits || 0));
 
@@ -204,6 +231,23 @@ export async function scanAll({ extraRoots = [], onProgress = () => {}, reported
   };
 }
 
+// One row of `scan --all --json`. The path stays on this computer (scan-all.json, stdout).
+export function scanEntry(p, i) {
+  const l = p._local || {};
+  return {
+    n: i + 1,
+    id: p.project.id,
+    name: p.project.name,
+    tokens: p.verified.ai?.tokens.total || 0,
+    last: p.verified.ai?.last_session || p.verified.git?.last_commit || null,
+    path: l.path || null,
+    exists: !!l.exists,
+    git: !!l.git,
+    setup: l.exists ? 'folder' : 'source',
+    url: p.verified.deploy?.url || null,
+  };
+}
+
 export function stripLocal(p) {
   const { _local, ...rest } = p;
   return rest;

package/src/table.mjs

@@ -69,10 +69,14 @@ export function projectTable(p) {
 }
 
 export function landTable(land) {
-  const rows = land.projects.map((p) => {
+  const yes = (x) => (x === undefined ? '-' : x ? 'O' : 'X');
+  const rows = land.projects.map((p, i) => {
     const a = p.verified.ai; const g = p.verified.git; const c = p.verified.code;
     return [
+      String(i + 1),
       p.project.name,
+      yes(p._local?.exists),
+      yes(p._local?.git),
       a ? compact(a.tokens.total) : '-',
       a ? compact(splitTokens(a).claude) : '-',
       a ? compact(splitTokens(a).gpt) : '-',
@@ -88,9 +92,10 @@ export function landTable(land) {
       lastActive(p) || '-',
     ];
   });
-  const head = ['프로젝트', '토큰', 'Claude', 'GPT', '캐시제외', '비용', '세션', '커밋', '일수', '줄', '배포', '공개', '별', '마지막'];
+  const head = ['#', '프로젝트', '폴더', 'Git', '토큰', 'Claude', 'GPT', '캐시제외', '비용', '세션', '커밋', '일수', '줄', '배포', '공개', '별', '마지막'];
+  const left = new Set([1, 2, 3, 14, 16]);
   const ws = head.map((h, i) => Math.max(width(h), ...rows.map((row) => width(row[i]))));
-  const fmt = (row) => row.map((x, i) => (i === 0 || i === 11 || i === 13 ? pad(x, ws[i]) : lpad(x, ws[i]))).join('  ');
+  const fmt = (row) => row.map((x, i) => (left.has(i) ? pad(x, ws[i]) : lpad(x, ws[i]))).join('  ');
   return [fmt(head), ws.map((w) => '-'.repeat(w)).join('  '), ...rows.map(fmt)].join('\n');
 }