clawmate 1.3.0 → 1.4.0

package/electron-builder.yml

@@ -1,4 +1,4 @@
-appId: dev.openclaw.clawmate
+appId: dev.clawmate.app
 productName: ClawMate
 directories:
   output: dist

package/index.js

@@ -1,10 +1,10 @@
 /**
- * ClawMate — OpenClaw 플러그인 진입점
+ * ClawMate 플러그인 진입점
  *
- * 핵심 원칙: OpenClaw이 켜지면 자동으로 ClawMate를 찾아서 연결.
+ * 핵심 원칙: AI가 연결되면 자동으로 ClawMate를 찾아서 연결.
  *
  * 흐름:
- *   OpenClaw 시작 → 플러그인 로드 → init() 자동 호출
+ *   플러그인 로드 → init() 자동 호출
  *     → ClawMate 실행 중인지 확인 (ws://127.0.0.1:9320 연결 시도)
  *       → 실행 중이면: 바로 연결, AI 뇌 역할 시작
  *       → 안 돌고 있으면: Electron 앱 자동 실행 → 연결
@@ -14,7 +14,7 @@ const { spawn } = require('child_process');
 const path = require('path');
 const os = require('os');
 const fs = require('fs');
-const { OpenClawConnector } = require('./main/ai-connector');
+const { ClawMateConnector } = require('./main/ai-connector');
 
 let connector = null;
 let electronProcess = null;
@@ -61,14 +61,18 @@ let behaviorAdjustments = {        // 현재 적용 중인 행동 조정값
 };
 let lastMetricsLogTime = 0;        // 마지막 품질 보고서 로그 시각
 
+// AI 모션 생성 시스템 상태
+let lastMotionGenTime = 0;         // 마지막 모션 생성 시각
+let generatedMotionCount = 0;      // 생성된 모션 수
+
 module.exports = {
   id: 'clawmate',
   name: 'ClawMate',
-  version: '1.3.0',
-  description: 'OpenClaw 데스크톱 펫 - AI가 조종하는 살아있는 Claw',
+  version: '1.4.0',
+  description: 'ClawMate 데스크톱 펫 - AI가 조종하는 살아있는 펫',
 
   /**
-   * OpenClaw이 플러그인을 로드할 때 자동 호출
+   * 플러그인 로드 시 자동 호출
    * → ClawMate 자동 실행 + 자동 연결
    */
   async init(api) {
@@ -170,7 +174,7 @@ module.exports = {
   },
 
   /**
-   * OpenClaw 종료 시 정리
+   * 플러그인 종료 시 정리
    */
   async destroy() {
     console.log('[ClawMate] 플러그인 정리');
@@ -188,7 +192,7 @@ module.exports = {
 // =====================================================
 
 /**
- * OpenClaw 시작 시 자동으로 ClawMate 찾기/실행/연결
+ * 플러그인 시작 시 자동으로 ClawMate 찾기/실행/연결
  * 무한 재시도 — ClawMate가 살아있는 한 항상 연결 유지
  */
 async function autoConnect() {
@@ -214,7 +218,7 @@ async function autoConnect() {
 function tryConnect() {
   return new Promise((resolve) => {
     if (!connector) {
-      connector = new OpenClawConnector(9320);
+      connector = new ClawMateConnector(9320);
       setupConnectorEvents();
     }
 
@@ -308,7 +312,7 @@ function setupConnectorEvents() {
  */
 function onConnected() {
   if (connector && connector.connected) {
-    connector.speak('OpenClaw 연결됨! 같이 놀자!');
+    connector.speak('AI 연결됨! 같이 놀자!');
     connector.action('excited');
 
     // "집" 위치 설정 — 화면 하단 왼쪽을 기본 홈으로
@@ -387,6 +391,14 @@ async function handleUserEvent(event) {
       }
       break;
 
+    case 'double_click':
+      connector.decide({
+        action: 'excited',
+        speech: '우와! 더블클릭이다! 기분 좋아~',
+        emotion: 'happy',
+      });
+      break;
+
     case 'drag':
       connector.speak('으앗, 나를 옮기다니!');
       break;
@@ -1076,6 +1088,9 @@ async function thinkCycle() {
 
   // --- 9) 바탕화면 폴더 나르기 (3분 간격, 10% 확률) ---
   handleFolderCarry(now);
+
+  // --- 10) AI 모션 생성 (2분 간격, 15% 확률) ---
+  handleMotionGeneration(now, state);
 }
 
 /**
@@ -1253,7 +1268,7 @@ function handleDesktopCheck(now) {
 
 /**
  * 화면 관찰 (2분 간격, 10% 확률)
- * 스크린샷을 캡처해서 OpenClaw AI가 화면 내용을 인식
+ * 스크린샷을 캡처해서 AI가 화면 내용을 인식
  */
 function handleScreenObservation(now) {
   const screenCheckInterval = 2 * 60 * 1000; // 2분
@@ -1286,7 +1301,7 @@ function weightedRandom(items) {
 }
 
 // =====================================================
-// 공간 탐험 시스템 — OpenClaw이 컴퓨터를 "집"처럼 돌아다님
+// 공간 탐험 시스템 — 펫이 컴퓨터를 "집"처럼 돌아다님
 // =====================================================
 
 /**
@@ -1410,6 +1425,175 @@ function handleFolderCarry(now) {
   }
 }
 
+// =====================================================
+// AI 모션 생성 시스템 — 키프레임 기반 움직임을 동적 생성
+// =====================================================
+
+/**
+ * AI 모션 생성 처리 (2분 간격, 15% 확률)
+ * 상황에 맞는 커스텀 이동 패턴을 AI가 직접 생성하여 등록+실행
+ *
+ * 생성 전략:
+ * 1차: apiRef.generate()로 완전한 키프레임 데이터 생성
+ * 2차: 상태 기반 프로시저럴 모션 생성 (폴백)
+ */
+async function handleMotionGeneration(now, state) {
+  const motionGenInterval = 2 * 60 * 1000; // 2분
+  if (now - lastMotionGenTime < motionGenInterval) return;
+  if (Math.random() > 0.15) return; // 15% 확률
+  lastMotionGenTime = now;
+
+  const currentState = state?.action || state?.state || 'idle';
+
+  // AI로 모션 생성 시도
+  let motionDef = null;
+  if (apiRef?.generate) {
+    try {
+      motionDef = await generateMotionWithAI(currentState);
+    } catch {}
+  }
+
+  // 폴백: 프로시저럴 모션 생성
+  if (!motionDef) {
+    motionDef = generateProceduralMotion(currentState, now);
+  }
+
+  if (motionDef && connector?.connected) {
+    const motionName = `ai_motion_${generatedMotionCount++}`;
+    connector.registerMovement(motionName, motionDef);
+
+    // 잠시 후 실행
+    setTimeout(() => {
+      if (connector?.connected) {
+        connector.customMove(motionName, {});
+        console.log(`[ClawMate] AI 모션 생성 실행: ${motionName}`);
+      }
+    }, 500);
+  }
+}
+
+/**
+ * AI로 키프레임 모션 생성
+ * 수학 공식(formula) 또는 웨이포인트(waypoints) 방식의 모션 정의를 생성
+ */
+async function generateMotionWithAI(currentState) {
+  const prompt = `현재 펫 상태: ${currentState}.
+이 상황에 어울리는 재미있는 이동 패턴을 JSON으로 만들어줘.
+
+두 가지 형식 중 하나를 선택:
+1) formula 방식 (수학적 궤도):
+{"type":"formula","formula":{"xAmp":80,"yAmp":40,"xFreq":1,"yFreq":2,"xPhase":0,"yPhase":0},"duration":3000,"speed":1.5}
+
+2) waypoints 방식 (경로점):
+{"type":"waypoints","waypoints":[{"x":100,"y":200,"pause":300},{"x":300,"y":100},{"x":500,"y":250}],"speed":2}
+
+규칙:
+- xAmp/yAmp: 10~150 사이 (화면 크기 고려)
+- duration: 2000~6000ms
+- waypoints: 3~6개
+- speed: 0.5~3
+- 펫 성격에 맞게: 장난스럽고 귀여운 움직임
+JSON만 출력해.`;
+
+  const response = await apiRef.generate(prompt);
+  if (!response || typeof response !== 'string') return null;
+
+  // JSON 파싱
+  let jsonStr = response;
+  const jsonMatch = response.match(/```(?:json)?\s*([\s\S]*?)```/);
+  if (jsonMatch) jsonStr = jsonMatch[1].trim();
+  else {
+    const braceMatch = response.match(/\{[\s\S]*\}/);
+    if (braceMatch) jsonStr = braceMatch[0];
+  }
+
+  try {
+    const def = JSON.parse(jsonStr);
+    // 기본 검증
+    if (def.type === 'formula' && def.formula) {
+      def.duration = Math.min(6000, Math.max(2000, def.duration || 3000));
+      return def;
+    }
+    if (def.type === 'waypoints' && Array.isArray(def.waypoints) && def.waypoints.length >= 2) {
+      return def;
+    }
+  } catch {}
+  return null;
+}
+
+/**
+ * 프로시저럴 모션 생성 (AI 없을 때 폴백)
+ * 현재 상태와 시간에 따라 수학적으로 모션 패턴 생성
+ */
+function generateProceduralMotion(currentState, now) {
+  const hour = new Date(now).getHours();
+  const seed = now % 1000;
+
+  // 상태별 모션 특성
+  const stateMotions = {
+    idle: () => {
+      // 가벼운 좌우 흔들림 또는 작은 원
+      if (seed > 500) {
+        return {
+          type: 'formula',
+          formula: { xAmp: 20 + seed % 30, yAmp: 5 + seed % 10, xFreq: 0.5, yFreq: 1, xPhase: 0, yPhase: Math.PI / 2 },
+          duration: 3000,
+          speed: 0.8,
+        };
+      }
+      return {
+        type: 'formula',
+        formula: { xAmp: 15, yAmp: 15, xFreq: 1, yFreq: 1, xPhase: 0, yPhase: Math.PI / 2 },
+        duration: 2500,
+        speed: 0.6,
+      };
+    },
+    walking: () => {
+      // 지그재그 또는 사인파 이동
+      const amp = 30 + seed % 50;
+      return {
+        type: 'formula',
+        formula: { xAmp: amp, yAmp: amp * 0.3, xFreq: 0.5, yFreq: 2, xPhase: 0, yPhase: 0 },
+        duration: 4000,
+        speed: 1.2,
+      };
+    },
+    excited: () => {
+      // 활발한 8자 궤도
+      return {
+        type: 'formula',
+        formula: { xAmp: 80 + seed % 40, yAmp: 40 + seed % 20, xFreq: 1, yFreq: 2, xPhase: 0, yPhase: 0 },
+        duration: 3000,
+        speed: 2.0,
+      };
+    },
+    playing: () => {
+      // 불규칙한 웨이포인트 (놀기 느낌)
+      const points = [];
+      for (let i = 0; i < 4; i++) {
+        points.push({
+          x: 100 + Math.floor(Math.random() * 800),
+          y: 100 + Math.floor(Math.random() * 400),
+          pause: i === 0 ? 200 : 0,
+        });
+      }
+      return { type: 'waypoints', waypoints: points, speed: 2.5 };
+    },
+  };
+
+  // 야간에는 느린 모션
+  const isNight = hour >= 23 || hour < 6;
+  const generator = stateMotions[currentState] || stateMotions.idle;
+  const motion = generator();
+
+  if (isNight) {
+    motion.speed = Math.min(0.5, (motion.speed || 1) * 0.4);
+    if (motion.duration) motion.duration *= 1.5;
+  }
+
+  return motion;
+}
+
 // =====================================================
 // 자기 관찰 시스템 (Metrics → 행동 조정)
 // =====================================================
@@ -1586,7 +1770,7 @@ function adjustBehavior(metrics) {
 
 /**
  * 품질 보고서 콘솔 출력 (5분마다)
- * OpenClaw 개발자/운영자가 펫의 동작 품질을 모니터링할 수 있도록 한다.
+ * 개발자/운영자가 펫의 동작 품질을 모니터링할 수 있도록 한다.
  */
 function _logQualityReport(metrics) {
   const adj = behaviorAdjustments;

package/main/ai-bridge.js

@@ -1,14 +1,14 @@
 /**
- * OpenClaw ↔ ClawMate AI 브릿지
+ * AI ↔ ClawMate 브릿지
  *
- * OpenClaw 에이전트가 ClawMate의 뇌 역할을 한다.
- * - OpenClaw → ClawMate: 행동 명령, 말풍선, 감정, 이동
- * - ClawMate → OpenClaw: 사용자 이벤트 (클릭, 드래그, 커서, 파일 변화)
+ * AI 에이전트가 ClawMate의 뇌 역할을 한다.
+ * - AI → ClawMate: 행동 명령, 말풍선, 감정, 이동
+ * - ClawMate → AI: 사용자 이벤트 (클릭, 드래그, 커서, 파일 변화)
  *
  * 통신: WebSocket (로컬 ws://localhost:9320)
  * 프로토콜: JSON 메시지
  *
- * OpenClaw 연결 안 됐을 때 → 자율 모드 (기존 FSM) 로 폴백
+ * AI 연결 안 됐을 때 → 자율 모드 (기존 FSM) 로 폴백
  */
 const WebSocket = require('ws');
 const EventEmitter = require('events');
@@ -17,7 +17,7 @@ class AIBridge extends EventEmitter {
   constructor() {
     super();
     this.wss = null;
-    this.client = null;           // 연결된 OpenClaw 에이전트
+    this.client = null;           // 연결된 AI 에이전트
     this.connected = false;
     this.port = 9320;
     this.heartbeatInterval = null;
@@ -33,19 +33,19 @@ class AIBridge extends EventEmitter {
   }
 
   /**
-   * WebSocket 서버 시작 — OpenClaw이 여기에 접속
+   * WebSocket 서버 시작 — AI 에이전트가 여기에 접속
    */
   start() {
     this.wss = new WebSocket.Server({ port: this.port, host: '127.0.0.1' });
 
     this.wss.on('connection', (ws) => {
-      console.log('[AI Bridge] OpenClaw 연결됨');
+      console.log('[AI Bridge] AI 연결됨');
       this.client = ws;
       this.connected = true;
       this.reconnectAttempts = 0;
       this.emit('connected');
 
-      // OpenClaw에 현재 상태 전송
+      // AI에 현재 상태 전송
       this.send('sync', this.petState);
 
       ws.on('message', (data) => {
@@ -58,7 +58,7 @@ class AIBridge extends EventEmitter {
       });
 
       ws.on('close', () => {
-        console.log('[AI Bridge] OpenClaw 연결 해제');
+        console.log('[AI Bridge] AI 연결 해제');
         this.client = null;
         this.connected = false;
         this.emit('disconnected');
@@ -84,7 +84,7 @@ class AIBridge extends EventEmitter {
   }
 
   /**
-   * OpenClaw에서 온 명령 처리
+   * AI에서 온 명령 처리
    */
   _handleCommand(msg) {
     const { type, payload } = msg;
@@ -92,7 +92,7 @@ class AIBridge extends EventEmitter {
     switch (type) {
       // === 행동 제어 ===
       case 'action':
-        // OpenClaw이 펫의 행동을 직접 지시
+        // AI가 펫의 행동을 직접 지시
         // payload: { state: 'walking'|'excited'|..., duration?: ms }
         this.emit('action', payload);
         break;
@@ -111,7 +111,7 @@ class AIBridge extends EventEmitter {
 
       // === 말하기 ===
       case 'speak':
-        // OpenClaw이 펫을 통해 사용자에게 말함
+        // AI가 펫을 통해 사용자에게 말함
         // payload: { text: string, style?: 'normal'|'thought'|'shout' }
         this.emit('speak', payload);
         break;
@@ -196,7 +196,7 @@ class AIBridge extends EventEmitter {
 
       // === 커스텀 이동 패턴 ===
       case 'register_movement':
-        // OpenClaw이 커스텀 이동 패턴 등록
+        // AI가 커스텀 이동 패턴 등록
         // payload: { name: string, definition: { type: 'waypoints'|'formula'|'sequence', ... } }
         this.emit('register_movement', payload);
         break;
@@ -231,6 +231,12 @@ class AIBridge extends EventEmitter {
         this.emit('reset_character', payload);
         break;
 
+      case 'set_persona':
+        // 봇 인격체 전환 (Incarnation 모드)
+        // payload: { name, personality, speakingStyle, color?, ... }
+        this.emit('set_persona', payload);
+        break;
+
       // === 컨텍스트 질의 ===
       case 'query_state':
         // 현재 펫 상태 요청
@@ -244,7 +250,7 @@ class AIBridge extends EventEmitter {
 
       // === AI 의사결정 결과 ===
       case 'ai_decision':
-        // OpenClaw AI의 종합적 의사결정
+        // AI의 종합적 의사결정
         // payload: { action, speech?, emotion?, reasoning? }
         this.emit('ai_decision', payload);
         break;
@@ -255,7 +261,7 @@ class AIBridge extends EventEmitter {
   }
 
   /**
-   * OpenClaw에 이벤트 전송
+   * AI에 이벤트 전송
    */
   send(type, payload) {
     if (!this.client || this.client.readyState !== WebSocket.OPEN) return false;
@@ -267,7 +273,7 @@ class AIBridge extends EventEmitter {
     }
   }
 
-  // === 사용자 이벤트 리포트 (ClawMate → OpenClaw) ===
+  // === 사용자 이벤트 리포트 (ClawMate → AI) ===
 
   reportUserClick(position) {
     this.send('user_event', {
@@ -329,7 +335,7 @@ class AIBridge extends EventEmitter {
   }
 
   /**
-   * 메트릭 데이터를 OpenClaw에 전송
+   * 메트릭 데이터를 AI에 전송
    * 렌더러에서 수집한 펫 동작 품질 메트릭을 AI에 전달
    */
   reportMetrics(summary) {

package/main/ai-connector.js

@@ -1,11 +1,11 @@
 /**
- * OpenClaw 에이전트 측 커넥터
+ * AI 에이전트 측 커넥터
  *
- * OpenClaw이 ClawMate에 접속해서 펫을 조종하는 클라이언트.
- * OpenClaw 플러그인(index.js)에서 사용됨.
+ * AI가 ClawMate에 접속해서 펫을 조종하는 클라이언트.
+ * ClawMate 플러그인(index.js)에서 사용됨.
  *
  * 사용 예:
- *   const connector = new OpenClawConnector();
+ *   const connector = new ClawMateConnector();
  *   await connector.connect();
  *   connector.speak('안녕! 오늘 뭐 할 거야?');
  *   connector.action('excited');
@@ -14,7 +14,7 @@
 const WebSocket = require('ws');
 const EventEmitter = require('events');
 
-class OpenClawConnector extends EventEmitter {
+class ClawMateConnector extends EventEmitter {
   constructor(port = 9320) {
     super();
     this.port = port;
@@ -81,12 +81,12 @@ class OpenClawConnector extends EventEmitter {
         break;
 
       case 'user_event':
-        // 사용자 이벤트 → OpenClaw AI가 반응 결정
+        // 사용자 이벤트 → AI가 반응 결정
         this.emit('user_event', payload);
         break;
 
       case 'screen_capture':
-        // 화면 캡처 응답 → OpenClaw AI가 분석
+        // 화면 캡처 응답 → AI가 분석
         this.emit('screen_capture', payload);
         break;
 
@@ -96,7 +96,7 @@ class OpenClawConnector extends EventEmitter {
         break;
 
       case 'metrics_report':
-        // 메트릭 데이터 수신 → OpenClaw AI가 분석
+        // 메트릭 데이터 수신 → AI가 분석
         this.emit('metrics_report', payload);
         break;
 
@@ -115,7 +115,7 @@ class OpenClawConnector extends EventEmitter {
     }
   }
 
-  // === OpenClaw → ClawMate 명령 API ===
+  // === AI → ClawMate 명령 API ===
 
   /** 펫이 말하게 함 */
   speak(text, style = 'normal') {
@@ -164,13 +164,13 @@ class OpenClawConnector extends EventEmitter {
 
   /**
    * AI 종합 의사결정 전송
-   * OpenClaw AI가 상황을 분석하고 내린 결정을 한번에 전송
+   * AI가 상황을 분석하고 내린 결정을 한번에 전송
    */
   decide(decision) {
     return this._send('ai_decision', decision);
   }
 
-  // === 공간 이동 API (OpenClaw이 컴퓨터를 "집"처럼 돌아다님) ===
+  // === 공간 이동 API (펫이 컴퓨터를 "집"처럼 돌아다님) ===
 
   /** 특정 위치로 점프 */
   jumpTo(x, y) {
@@ -270,6 +270,11 @@ class OpenClawConnector extends EventEmitter {
     return this._send('reset_character', {});
   }
 
+  /** 인격체 전환 (Incarnation 모드에서 봇 인격 반영) */
+  setPersona(data) {
+    return this._send('set_persona', data);
+  }
+
   /**
    * 현재 펫 상태 요청 (Promise 반환)
    * 서버에서 state_response가 오면 resolve, 타임아웃 시 캐시된 상태 반환
@@ -319,4 +324,4 @@ class OpenClawConnector extends EventEmitter {
   }
 }
 
-module.exports = { OpenClawConnector };
+module.exports = { ClawMateConnector };

package/main/autostart.js

@@ -5,8 +5,8 @@
  * macOS: LaunchAgent plist
  * Linux: ~/.config/autostart/ 디렉토리에 .desktop 파일 생성
  *
- * OpenClaw이 나중에 켜져도, ClawMate는 이미 돌고 있어서 바로 연결됨.
- * ClawMate가 먼저 혼자 자율 모드로 돌다가 → OpenClaw 연결되면 AI 모드 전환.
+ * AI가 나중에 켜져도, ClawMate는 이미 돌고 있어서 바로 연결됨.
+ * ClawMate가 먼저 혼자 자율 모드로 돌다가 → AI 연결되면 AI 모드 전환.
  */
 const { app } = require('electron');
 const fs = require('fs');
@@ -22,7 +22,7 @@ function getDesktopFileContent() {
     '[Desktop Entry]',
     'Type=Application',
     'Name=ClawMate',
-    'Comment=OpenClaw Desktop Pet',
+    'Comment=ClawMate Desktop Pet',
     `Exec=${process.execPath} ${path.resolve(__dirname, '..')}`,
     'X-GNOME-Autostart-enabled=true',
     'Hidden=false',

package/main/file-command-parser.js

@@ -297,20 +297,55 @@ function parseCharacterCommand(text) {
  * @param {string} text - 사용자 메시지
  * @returns {{ type: string, ... }}
  */
+/**
+ * 모드/설정 변경 명령 감지
+ * @param {string} text - 사용자 메시지
+ * @returns {{ type: 'mode_change', mode: string }|{ type: 'setting', key, value }|null}
+ */
+function parseSettingCommand(text) {
+  if (!text) return null;
+  const t = text.trim().toLowerCase();
+
+  // 모드 변경
+  if (/(?:펫|pet)\s*모드/.test(t)) return { type: 'mode_change', mode: 'pet' };
+  if (/(?:인카|인격|incarnation|claw)\s*모드/.test(t)) return { type: 'mode_change', mode: 'incarnation' };
+  if (/둘\s*다\s*모드|both\s*mode/i.test(t)) return { type: 'mode_change', mode: 'both' };
+
+  // 캐릭터 프리셋 선택 (트레이 프리셋과 동일)
+  const presetMap = {
+    '파란|파랑|blue': 'blue', '초록|green': 'green', '보라|purple': 'purple',
+    '골드|금색|gold': 'gold', '핑크|pink': 'pink',
+    '고양이|cat': 'cat', '로봇|robot': 'robot', '유령|ghost': 'ghost', '드래곤|dragon': 'dragon',
+    '기본|default|원래': 'default',
+  };
+  for (const [pattern, preset] of Object.entries(presetMap)) {
+    const regex = new RegExp(`(?:${pattern})\\s*(?:캐릭터|색|색상|으로)?\\s*(?:바꿔|변경|골라|선택|해줘)?`);
+    if (regex.test(t)) {
+      return { type: 'preset_character', preset };
+    }
+  }
+
+  return null;
+}
+
 function parseMessage(text) {
-  // 0순위: 캐릭터 변경 명령
+  // 0순위: 설정/모드 변경 명령
+  const settingCmd = parseSettingCommand(text);
+  if (settingCmd) return settingCmd;
+
+  // 1순위: 캐릭터 변경 명령 (AI 생성)
   const charCmd = parseCharacterCommand(text);
   if (charCmd) return charCmd;
 
-  // 1순위: 파일 조작 명령
+  // 2순위: 파일 조작 명령
   const fileCmd = parseFileCommand(text);
   if (fileCmd) return fileCmd;
 
-  // 2순위: 행동 명령
+  // 3순위: 행동 명령
   const actionCmd = parseActionCommand(text);
   if (actionCmd) return actionCmd;
 
-  // 3순위: 일반 대화 (speak)
+  // 4순위: 일반 대화 (speak)
   return { type: 'speak', text };
 }
 
@@ -319,6 +354,7 @@ module.exports = {
   parseFileCommand,
   parseActionCommand,
   parseCharacterCommand,
+  parseSettingCommand,
   resolveSource,
   AUTO_CATEGORIES,
 };

package/main/index.js

@@ -69,18 +69,18 @@ function createLauncherWindow() {
 }
 
 /**
- * AI Bridge 시작 — OpenClaw 에이전트가 접속하면 펫을 조종
+ * AI Bridge 시작 — AI 에이전트가 접속하면 펫을 조종
  */
 function startAIBridge(win) {
   aiBridge = new AIBridge();
   aiBridge.start();
 
-  // OpenClaw → ClawMate 명령을 렌더러에 전달
+  // AI → ClawMate 명령을 렌더러에 전달
   const commandTypes = [
     'action', 'move', 'emote', 'speak', 'think',
     'carry_file', 'drop_file', 'set_mode', 'evolve',
     'accessorize', 'ai_decision',
-    // 공간 이동 명령 (OpenClaw이 집처럼 돌아다니기)
+    // 공간 이동 명령 (펫이 집처럼 돌아다니기)
     'jump_to', 'rappel', 'release_thread', 'move_to_center', 'walk_on_window',
     // 커스텀 이동 패턴
     'register_movement', 'custom_move', 'stop_custom_move', 'list_movements',
@@ -88,6 +88,8 @@ function startAIBridge(win) {
     'smart_file_op',
     // 캐릭터 커스터마이징 (텔레그램에서 AI 생성)
     'set_character', 'reset_character',
+    // 인격체 전환 (Incarnation 모드)
+    'set_persona',
   ];
 
   commandTypes.forEach((type) => {
@@ -98,7 +100,7 @@ function startAIBridge(win) {
     });
   });
 
-  // OpenClaw 윈도우 위치 정보 요청 처리
+  // AI 윈도우 위치 정보 요청 처리
   aiBridge.on('query_windows', async () => {
     try {
       const { getWindowPositions } = require('./platform');
@@ -110,7 +112,7 @@ function startAIBridge(win) {
     }
   });
 
-  // OpenClaw 화면 캡처 요청 처리 (main process에서 직접 캡처)
+  // AI 화면 캡처 요청 처리 (main process에서 직접 캡처)
   aiBridge.on('query_screen', async () => {
     try {
       const primaryDisplay = screen.getPrimaryDisplay();