triflux 3.2.0-dev.11 → 3.2.0-dev.13

package/hooks/hooks.json

@@ -24,6 +24,18 @@
           }
         ]
       }
+    ],
+    "Stop": [
+      {
+        "matcher": "*",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/hooks/pipeline-stop.mjs\"",
+            "timeout": 5
+          }
+        ]
+      }
     ]
   }
 }

package/hooks/pipeline-stop.mjs

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+// hooks/pipeline-stop.mjs — 파이프라인 진행 중 세션 중단 시 지속 프롬프트 주입
+//
+// Claude Code의 Stop 이벤트에서 실행.
+// 비터미널 단계의 파이프라인이 있으면 "작업 계속" 프롬프트를 반환한다.
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const HUB_DB_PATH = join(homedir(), '.claude', 'cache', 'tfx-hub', 'state.db');
+const TERMINAL = new Set(['complete', 'failed']);
+
+async function getPipelineStopPrompt() {
+  if (!existsSync(HUB_DB_PATH)) return null;
+
+  try {
+    const { default: Database } = await import('better-sqlite3');
+    const { ensurePipelineTable, listPipelineStates } = await import(
+      join(process.env.CLAUDE_PLUGIN_ROOT || '.', 'hub', 'pipeline', 'state.mjs')
+    );
+
+    const db = new Database(HUB_DB_PATH, { readonly: true });
+    ensurePipelineTable(db);
+    const states = listPipelineStates(db);
+    db.close();
+
+    // 비터미널 단계의 활성 파이프라인 찾기
+    const active = states.filter((s) => !TERMINAL.has(s.phase));
+    if (active.length === 0) return null;
+
+    const lines = active.map((s) =>
+      `- 팀 ${s.team_name}: ${s.phase} 단계 (fix: ${s.fix_attempt}/${s.fix_max}, ralph: ${s.ralph_iteration}/${s.ralph_max})`
+    );
+
+    return `[tfx-multi 파이프라인 진행 중]
+활성 파이프라인이 있습니다:
+${lines.join('\n')}
+
+파이프라인을 이어서 진행하려면 /tfx-multi status 로 상태를 확인하세요.`;
+  } catch {
+    return null;
+  }
+}
+
+try {
+  const prompt = await getPipelineStopPrompt();
+  if (prompt) {
+    // hook 출력으로 지속 프롬프트 전달
+    console.log(prompt);
+  }
+} catch {
+  // stop 훅 실패는 무시
+}

package/hub/bridge.mjs

@@ -12,6 +12,16 @@ import { parseArgs as nodeParseArgs } from 'node:util';
 import { randomUUID } from 'node:crypto';
 
 const HUB_PID_FILE = join(homedir(), '.claude', 'cache', 'tfx-hub', 'hub.pid');
+const HUB_TOKEN_FILE = join(homedir(), '.claude', '.tfx-hub-token');
+
+// Hub 인증 토큰 읽기 (파일 없으면 null → 하위 호환)
+function readHubToken() {
+  try {
+    return readFileSync(HUB_TOKEN_FILE, 'utf8').trim();
+  } catch {
+    return null;
+  }
+}
 
 export function getHubUrl() {
   if (process.env.TFX_HUB_URL) return process.env.TFX_HUB_URL.replace(/\/mcp$/, '');
@@ -46,9 +56,15 @@ export async function post(path, body, timeoutMs = 5000) {
   const timer = setTimeout(() => controller.abort(), timeoutMs);
 
   try {
+    const headers = { 'Content-Type': 'application/json' };
+    const token = readHubToken();
+    if (token) {
+      headers['Authorization'] = `Bearer ${token}`;
+    }
+
     const res = await fetch(`${getHubUrl()}${path}`, {
       method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
+      headers,
       body: JSON.stringify(body),
       signal: controller.signal,
     });
@@ -304,27 +320,41 @@ async function cmdDeregister(args) {
 }
 
 async function cmdTeamInfo(args) {
-  const result = await post('/bridge/team/info', {
+  const body = {
     team_name: args.team,
     include_members: true,
     include_paths: true,
-  });
-  console.log(JSON.stringify(result || { ok: false, reason: 'hub_unavailable' }));
+  };
+  const result = await post('/bridge/team/info', body);
+  if (result) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  // Hub 미실행 fallback — nativeProxy 직접 호출
+  const { teamInfo } = await import('./team/nativeProxy.mjs');
+  console.log(JSON.stringify(await teamInfo(body)));
 }
 
 async function cmdTeamTaskList(args) {
-  const result = await post('/bridge/team/task-list', {
+  const body = {
     team_name: args.team,
     owner: args.owner,
     statuses: args.statuses ? args.statuses.split(',').map((status) => status.trim()).filter(Boolean) : [],
     include_internal: !!args['include-internal'],
     limit: parseInt(args.limit || '200', 10),
-  });
-  console.log(JSON.stringify(result || { ok: false, reason: 'hub_unavailable' }));
+  };
+  const result = await post('/bridge/team/task-list', body);
+  if (result) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  // Hub 미실행 fallback — nativeProxy 직접 호출
+  const { teamTaskList } = await import('./team/nativeProxy.mjs');
+  console.log(JSON.stringify(await teamTaskList(body)));
 }
 
 async function cmdTeamTaskUpdate(args) {
-  const result = await post('/bridge/team/task-update', {
+  const body = {
     team_name: args.team,
     task_id: args['task-id'],
     claim: !!args.claim,
@@ -338,20 +368,95 @@ async function cmdTeamTaskUpdate(args) {
     metadata_patch: args['metadata-patch'] ? parseJsonSafe(args['metadata-patch'], null) : undefined,
     if_match_mtime_ms: args['if-match-mtime-ms'] != null ? Number(args['if-match-mtime-ms']) : undefined,
     actor: args.actor,
-  });
-  console.log(JSON.stringify(result || { ok: false, reason: 'hub_unavailable' }));
+  };
+  const result = await post('/bridge/team/task-update', body);
+  if (result) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  // Hub 미실행 fallback — nativeProxy 직접 호출
+  const { teamTaskUpdate } = await import('./team/nativeProxy.mjs');
+  console.log(JSON.stringify(await teamTaskUpdate(body)));
 }
 
 async function cmdTeamSendMessage(args) {
-  const result = await post('/bridge/team/send-message', {
+  const body = {
     team_name: args.team,
     from: args.from,
     to: args.to || 'team-lead',
     text: args.text,
     summary: args.summary,
     color: args.color || 'blue',
+  };
+  const result = await post('/bridge/team/send-message', body);
+  if (result) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  // Hub 미실행 fallback — nativeProxy 직접 호출
+  const { teamSendMessage } = await import('./team/nativeProxy.mjs');
+  console.log(JSON.stringify(await teamSendMessage(body)));
+}
+
+function getHubDbPath() {
+  return join(homedir(), '.claude', 'cache', 'tfx-hub', 'state.db');
+}
+
+async function cmdPipelineState(args) {
+  // HTTP 우선
+  const result = await post('/bridge/pipeline/state', { team_name: args.team });
+  if (result) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  // Hub 미실행 fallback — 직접 SQLite 접근
+  try {
+    const { default: Database } = await import('better-sqlite3');
+    const { ensurePipelineTable, readPipelineState } = await import('./pipeline/state.mjs');
+    const dbPath = getHubDbPath();
+    if (!existsSync(dbPath)) {
+      console.log(JSON.stringify({ ok: false, error: 'hub_db_not_found' }));
+      return;
+    }
+    const db = new Database(dbPath, { readonly: true });
+    ensurePipelineTable(db);
+    const state = readPipelineState(db, args.team);
+    db.close();
+    console.log(JSON.stringify(state
+      ? { ok: true, data: state }
+      : { ok: false, error: 'pipeline_not_found' }));
+  } catch (e) {
+    console.log(JSON.stringify({ ok: false, error: e.message }));
+  }
+}
+
+async function cmdPipelineAdvance(args) {
+  // HTTP 우선
+  const result = await post('/bridge/pipeline/advance', {
+    team_name: args.team,
+    phase: args.status, // --status를 phase로 재활용
   });
-  console.log(JSON.stringify(result || { ok: false, reason: 'hub_unavailable' }));
+  if (result) {
+    console.log(JSON.stringify(result));
+    return;
+  }
+  // Hub 미실행 fallback — 직접 SQLite 접근
+  try {
+    const { default: Database } = await import('better-sqlite3');
+    const { createPipeline } = await import('./pipeline/index.mjs');
+    const dbPath = getHubDbPath();
+    if (!existsSync(dbPath)) {
+      console.log(JSON.stringify({ ok: false, error: 'hub_db_not_found' }));
+      return;
+    }
+    const db = new Database(dbPath);
+    const pipeline = createPipeline(db, args.team);
+    const advanceResult = pipeline.advance(args.status);
+    db.close();
+    console.log(JSON.stringify(advanceResult));
+  } catch (e) {
+    console.log(JSON.stringify({ ok: false, error: e.message }));
+  }
 }
 
 async function cmdPing() {
@@ -397,9 +502,11 @@ export async function main(argv = process.argv.slice(2)) {
     case 'team-task-list': await cmdTeamTaskList(args); break;
     case 'team-task-update': await cmdTeamTaskUpdate(args); break;
     case 'team-send-message': await cmdTeamSendMessage(args); break;
+    case 'pipeline-state': await cmdPipelineState(args); break;
+    case 'pipeline-advance': await cmdPipelineAdvance(args); break;
     case 'ping': await cmdPing(args); break;
     default:
-      console.error('사용법: bridge.mjs <register|result|context|deregister|team-info|team-task-list|team-task-update|team-send-message|ping> [--옵션]');
+      console.error('사용법: bridge.mjs <register|result|context|deregister|team-info|team-task-list|team-task-update|team-send-message|pipeline-state|pipeline-advance|ping> [--옵션]');
       process.exit(1);
   }
 }

package/hub/pipeline/index.mjs

@@ -0,0 +1,121 @@
+// hub/pipeline/index.mjs — 파이프라인 매니저
+//
+// 상태(state.mjs) + 전이(transitions.mjs) 통합 인터페이스
+
+import { canTransition, transitionPhase, ralphRestart, TERMINAL } from './transitions.mjs';
+import {
+  ensurePipelineTable,
+  initPipelineState,
+  readPipelineState,
+  updatePipelineState,
+  removePipelineState,
+} from './state.mjs';
+
+/**
+ * 파이프라인 매니저 생성
+ * @param {object} db - better-sqlite3 인스턴스 (store.db)
+ * @param {string} teamName
+ * @param {object} opts - { fix_max?, ralph_max? }
+ * @returns {object} 파이프라인 API
+ */
+export function createPipeline(db, teamName, opts = {}) {
+  ensurePipelineTable(db);
+
+  // 기존 상태가 있으면 로드, 없으면 초기화
+  let state = readPipelineState(db, teamName);
+  if (!state) {
+    state = initPipelineState(db, teamName, opts);
+  }
+
+  return {
+    /**
+     * 현재 상태 조회
+     */
+    getState() {
+      state = readPipelineState(db, teamName) || state;
+      return { ...state };
+    },
+
+    /**
+     * 다음 단계로 전이 가능 여부
+     * @param {string} phase
+     */
+    canAdvance(phase) {
+      const current = readPipelineState(db, teamName);
+      return current ? canTransition(current.phase, phase) : false;
+    },
+
+    /**
+     * 다음 단계로 전이
+     * @param {string} nextPhase
+     * @returns {{ ok: boolean, state?: object, error?: string }}
+     */
+    advance(nextPhase) {
+      const current = readPipelineState(db, teamName);
+      if (!current) {
+        return { ok: false, error: `파이프라인 없음: ${teamName}` };
+      }
+
+      const result = transitionPhase(current, nextPhase);
+      if (!result.ok) return result;
+
+      state = updatePipelineState(db, teamName, result.state);
+      return { ok: true, state: { ...state } };
+    },
+
+    /**
+     * ralph loop 재시작 (plan부터 다시)
+     * @returns {{ ok: boolean, state?: object, error?: string }}
+     */
+    restart() {
+      const current = readPipelineState(db, teamName);
+      if (!current) {
+        return { ok: false, error: `파이프라인 없음: ${teamName}` };
+      }
+
+      const result = ralphRestart(current);
+      if (!result.ok) return result;
+
+      state = updatePipelineState(db, teamName, result.state);
+      return { ok: true, state: { ...state } };
+    },
+
+    /**
+     * artifact 저장 (plan_path, prd_path, verify_report 등)
+     * @param {string} key
+     * @param {*} value
+     */
+    setArtifact(key, value) {
+      const current = readPipelineState(db, teamName);
+      if (!current) return;
+      const artifacts = { ...(current.artifacts || {}), [key]: value };
+      state = updatePipelineState(db, teamName, { artifacts });
+    },
+
+    /**
+     * 터미널 상태 여부
+     */
+    isTerminal() {
+      const current = readPipelineState(db, teamName);
+      return current ? TERMINAL.has(current.phase) : true;
+    },
+
+    /**
+     * 파이프라인 초기화 (리셋)
+     */
+    reset() {
+      state = initPipelineState(db, teamName, opts);
+      return { ...state };
+    },
+
+    /**
+     * 파이프라인 삭제
+     */
+    remove() {
+      return removePipelineState(db, teamName);
+    },
+  };
+}
+
+export { ensurePipelineTable } from './state.mjs';
+export { PHASES, TERMINAL, ALLOWED, canTransition } from './transitions.mjs';

package/hub/pipeline/state.mjs

@@ -0,0 +1,164 @@
+// hub/pipeline/state.mjs — Hub SQLite 파이프라인 상태 저장/로드
+//
+// store.mjs의 기존 SQLite 연결(db)을 활용한다.
+// pipeline_state 테이블은 schema.sql에 정의.
+
+/**
+ * pipeline_state 테이블 초기화 (store.db에 없으면 생성)
+ * @param {object} db - better-sqlite3 인스턴스
+ */
+export function ensurePipelineTable(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS pipeline_state (
+      team_name TEXT PRIMARY KEY,
+      phase TEXT NOT NULL DEFAULT 'plan',
+      fix_attempt INTEGER DEFAULT 0,
+      fix_max INTEGER DEFAULT 3,
+      ralph_iteration INTEGER DEFAULT 0,
+      ralph_max INTEGER DEFAULT 10,
+      artifacts TEXT DEFAULT '{}',
+      phase_history TEXT DEFAULT '[]',
+      created_at INTEGER,
+      updated_at INTEGER
+    )
+  `);
+}
+
+const STATEMENTS = new WeakMap();
+
+function getStatements(db) {
+  let s = STATEMENTS.get(db);
+  if (s) return s;
+
+  s = {
+    get: db.prepare('SELECT * FROM pipeline_state WHERE team_name = ?'),
+    insert: db.prepare(`
+      INSERT INTO pipeline_state (team_name, phase, fix_attempt, fix_max, ralph_iteration, ralph_max, artifacts, phase_history, created_at, updated_at)
+      VALUES (@team_name, @phase, @fix_attempt, @fix_max, @ralph_iteration, @ralph_max, @artifacts, @phase_history, @created_at, @updated_at)
+    `),
+    update: db.prepare(`
+      UPDATE pipeline_state SET
+        phase = @phase,
+        fix_attempt = @fix_attempt,
+        fix_max = @fix_max,
+        ralph_iteration = @ralph_iteration,
+        ralph_max = @ralph_max,
+        artifacts = @artifacts,
+        phase_history = @phase_history,
+        updated_at = @updated_at
+      WHERE team_name = @team_name
+    `),
+    remove: db.prepare('DELETE FROM pipeline_state WHERE team_name = ?'),
+    list: db.prepare('SELECT * FROM pipeline_state ORDER BY updated_at DESC'),
+  };
+  STATEMENTS.set(db, s);
+  return s;
+}
+
+function parseRow(row) {
+  if (!row) return null;
+  return {
+    ...row,
+    artifacts: JSON.parse(row.artifacts || '{}'),
+    phase_history: JSON.parse(row.phase_history || '[]'),
+  };
+}
+
+function serializeState(state) {
+  return {
+    team_name: state.team_name,
+    phase: state.phase || 'plan',
+    fix_attempt: state.fix_attempt ?? 0,
+    fix_max: state.fix_max ?? 3,
+    ralph_iteration: state.ralph_iteration ?? 0,
+    ralph_max: state.ralph_max ?? 10,
+    artifacts: JSON.stringify(state.artifacts || {}),
+    phase_history: JSON.stringify(state.phase_history || []),
+    created_at: state.created_at ?? Date.now(),
+    updated_at: state.updated_at ?? Date.now(),
+  };
+}
+
+/**
+ * 파이프라인 상태 초기화 (새 파이프라인)
+ * @param {object} db - better-sqlite3 인스턴스
+ * @param {string} teamName
+ * @param {object} opts - { fix_max?, ralph_max? }
+ * @returns {object} 초기 상태
+ */
+export function initPipelineState(db, teamName, opts = {}) {
+  const S = getStatements(db);
+  const now = Date.now();
+  const state = {
+    team_name: teamName,
+    phase: 'plan',
+    fix_attempt: 0,
+    fix_max: opts.fix_max ?? 3,
+    ralph_iteration: 0,
+    ralph_max: opts.ralph_max ?? 10,
+    artifacts: {},
+    phase_history: [],
+    created_at: now,
+    updated_at: now,
+  };
+
+  // 기존 상태가 있으면 삭제 후 재생성
+  S.remove.run(teamName);
+  S.insert.run(serializeState(state));
+  return state;
+}
+
+/**
+ * 파이프라인 상태 조회
+ * @param {object} db - better-sqlite3 인스턴스
+ * @param {string} teamName
+ * @returns {object|null}
+ */
+export function readPipelineState(db, teamName) {
+  const S = getStatements(db);
+  return parseRow(S.get.get(teamName));
+}
+
+/**
+ * 파이프라인 상태 업데이트 (부분 패치)
+ * @param {object} db - better-sqlite3 인스턴스
+ * @param {string} teamName
+ * @param {object} patch - 업데이트할 필드
+ * @returns {object|null} 업데이트된 상태
+ */
+export function updatePipelineState(db, teamName, patch) {
+  const S = getStatements(db);
+  const current = parseRow(S.get.get(teamName));
+  if (!current) return null;
+
+  const merged = {
+    ...current,
+    ...patch,
+    team_name: teamName, // team_name 변경 불가
+    updated_at: Date.now(),
+  };
+
+  S.update.run(serializeState(merged));
+  return merged;
+}
+
+/**
+ * 파이프라인 상태 삭제
+ * @param {object} db - better-sqlite3 인스턴스
+ * @param {string} teamName
+ * @returns {boolean}
+ */
+export function removePipelineState(db, teamName) {
+  const S = getStatements(db);
+  return S.remove.run(teamName).changes > 0;
+}
+
+/**
+ * 활성 파이프라인 목록
+ * @param {object} db - better-sqlite3 인스턴스
+ * @returns {object[]}
+ */
+export function listPipelineStates(db) {
+  const S = getStatements(db);
+  return S.list.all().map(parseRow);
+}

package/hub/pipeline/transitions.mjs

@@ -0,0 +1,114 @@
+// hub/pipeline/transitions.mjs — 파이프라인 단계 전이 규칙
+//
+// plan → prd → exec → verify → complete/fix
+// fix → exec/verify/complete/failed
+// complete, failed = 터미널 상태
+
+export const PHASES = ['plan', 'prd', 'exec', 'verify', 'fix', 'complete', 'failed'];
+
+export const TERMINAL = new Set(['complete', 'failed']);
+
+export const ALLOWED = {
+  'plan':     ['prd'],
+  'prd':      ['exec'],
+  'exec':     ['verify'],
+  'verify':   ['fix', 'complete', 'failed'],
+  'fix':      ['exec', 'verify', 'complete', 'failed'],
+  'complete': [],
+  'failed':   [],
+};
+
+/**
+ * 전이 가능 여부 확인
+ * @param {string} from - 현재 단계
+ * @param {string} to - 다음 단계
+ * @returns {boolean}
+ */
+export function canTransition(from, to) {
+  const targets = ALLOWED[from];
+  if (!targets) return false;
+  return targets.includes(to);
+}
+
+/**
+ * 상태 전이 실행 — fix loop 바운딩 포함
+ * @param {object} state - 파이프라인 상태 객체
+ * @param {string} nextPhase - 다음 단계
+ * @returns {{ ok: boolean, state?: object, error?: string }}
+ */
+export function transitionPhase(state, nextPhase) {
+  const current = state.phase;
+
+  if (!canTransition(current, nextPhase)) {
+    return {
+      ok: false,
+      error: `전이 불가: ${current} → ${nextPhase}. 허용: [${(ALLOWED[current] || []).join(', ')}]`,
+    };
+  }
+
+  const next = { ...state, phase: nextPhase, updated_at: Date.now() };
+
+  // fix 단계 진입 시 attempt 증가 + 바운딩
+  if (nextPhase === 'fix') {
+    next.fix_attempt = (state.fix_attempt || 0) + 1;
+    if (next.fix_attempt > (state.fix_max || 3)) {
+      return {
+        ok: false,
+        error: `fix loop 초과: ${next.fix_attempt}/${state.fix_max || 3}회. ralph loop로 승격 필요.`,
+      };
+    }
+  }
+
+  // fix → exec 재진입 시 (fix 후 재실행)
+  if (current === 'fix' && nextPhase === 'exec') {
+    // fix_attempt 유지 (이미 fix 진입 시 증가됨)
+  }
+
+  // verify → fix → ... → verify 반복 후 fix_max 초과 시 ralph loop
+  if (nextPhase === 'failed' && current === 'fix') {
+    // ralph loop 반복 증가
+    next.ralph_iteration = (state.ralph_iteration || 0) + 1;
+    if (next.ralph_iteration > (state.ralph_max || 10)) {
+      // 최종 실패 — ralph loop도 초과
+      next.phase = 'failed';
+    }
+  }
+
+  // phase_history 기록
+  const history = Array.isArray(state.phase_history) ? [...state.phase_history] : [];
+  history.push({ from: current, to: nextPhase, at: Date.now() });
+  next.phase_history = history;
+
+  return { ok: true, state: next };
+}
+
+/**
+ * ralph loop 재시작 전이
+ * fix_max 초과 시 plan으로 돌아가며 ralph_iteration 증가
+ * @param {object} state - 현재 상태
+ * @returns {{ ok: boolean, state?: object, error?: string }}
+ */
+export function ralphRestart(state) {
+  const iteration = (state.ralph_iteration || 0) + 1;
+  if (iteration > (state.ralph_max || 10)) {
+    return {
+      ok: false,
+      error: `ralph loop 초과: ${iteration}/${state.ralph_max || 10}회. 최종 실패.`,
+    };
+  }
+
+  const history = Array.isArray(state.phase_history) ? [...state.phase_history] : [];
+  history.push({ from: state.phase, to: 'plan', at: Date.now(), ralph_restart: true });
+
+  return {
+    ok: true,
+    state: {
+      ...state,
+      phase: 'plan',
+      fix_attempt: 0,
+      ralph_iteration: iteration,
+      phase_history: history,
+      updated_at: Date.now(),
+    },
+  };
+}

package/hub/schema.sql

@@ -78,3 +78,17 @@ CREATE INDEX IF NOT EXISTS idx_inbox_message ON message_inbox(message_id);
 CREATE INDEX IF NOT EXISTS idx_human_requests_state ON human_requests(state);
 CREATE INDEX IF NOT EXISTS idx_agents_status ON agents(status);
 CREATE INDEX IF NOT EXISTS idx_agents_lease ON agents(lease_expires_ms);
+
+-- 파이프라인 상태 테이블 (Phase 2)
+CREATE TABLE IF NOT EXISTS pipeline_state (
+  team_name TEXT PRIMARY KEY,
+  phase TEXT NOT NULL DEFAULT 'plan',
+  fix_attempt INTEGER DEFAULT 0,
+  fix_max INTEGER DEFAULT 3,
+  ralph_iteration INTEGER DEFAULT 0,
+  ralph_max INTEGER DEFAULT 10,
+  artifacts TEXT DEFAULT '{}',
+  phase_history TEXT DEFAULT '[]',
+  created_at INTEGER,
+  updated_at INTEGER
+);