luang-cli 0.2.0 → 0.3.2

package/lib/agent.js

@@ -1,9 +1,21 @@
 'use strict';
 
-// lib/agent.js — daemon agent, task list/create/status, status ringkas,
-// dan mcp-config. Bagian lanjutan dari lib/commands.js.
+// lib/agent.js — daemon agent: realtime WebSocket (docs/agent-realtime-ws.md),
+// fallback polling HTTP lama, task list/create/status, status ringkas, mcp-config.
+// Bagian lanjutan dari lib/commands.js.
 
-const { exec } = require('child_process');
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const pkg = require('../package.json');
+
+// lib/ws bisa gagal dimuat di Node yang sangat tua → daemon tetap jalan via polling.
+let wsLib = null;
+try {
+  wsLib = require('./ws');
+} catch (e) {
+  wsLib = null;
+}
 
 const core = require('./core');
 const c = require('./commands');
@@ -12,10 +24,15 @@ const {
   apiRequest,
   loadState,
   saveState,
+  saveConfig,
   collectProviders,
+  heartbeatProviders,
+  resolveWorkspace,
   DEFAULT_TEMPLATES,
+  DISPLAY_NAMES,
   STATE_FILE,
   CONFIG_DIR,
+  modelsForProvider,
   fmtWhen,
   keyPrefix,
   trunc,
@@ -25,6 +42,14 @@ const {
 
 const STATUS_LABELS = { todo: 'To-Do', in_progress: 'In Progress', review: 'Review', done: 'Done' };
 
+const WS_PATH = '/api/v1/agent/ws'; // kontrak: docs/agent-realtime-ws.md §1
+const REALTIME_GUARD_MS = 12000;    // beri waktu beberapa percobaan WS sebelum fallback
+
+// File daemon background (lihat `luang-cli agent start|stop|status|logs`).
+const BIN = path.join(__dirname, '..', 'bin', 'luang-cli.js');
+const PID_FILE = path.join(CONFIG_DIR, 'agent.pid'); // JSON {pid, started_at, auto, mode}
+const LOG_FILE = path.join(CONFIG_DIR, 'agent.log');
+
 // ── agent (daemon) ───────────────────────────────────────────────────────────
 
 function stampNow() {
@@ -33,6 +58,80 @@ function stampNow() {
   return `${p2(d.getHours())}:${p2(d.getMinutes())}:${p2(d.getSeconds())}`;
 }
 
+// ── util file daemon background ──────────────────────────────────────────────
+
+function tildePath(p) {
+  const home = process.env.HOME;
+  return home ? String(p).replace(home, '~') : String(p);
+}
+
+// hidup? (process.kill(pid, 0) — EPERM = hidup tapi bukan milik kita)
+function isPidAlive(pid) {
+  const n = Number(pid);
+  if (!Number.isInteger(n) || n <= 0) return false;
+  try {
+    process.kill(n, 0);
+    return true;
+  } catch (e) {
+    return !!(e && e.code === 'EPERM');
+  }
+}
+
+function readPidInfo() {
+  try {
+    const raw = JSON.parse(fs.readFileSync(PID_FILE, 'utf8'));
+    const pid = Number(raw && raw.pid);
+    if (Number.isInteger(pid) && pid > 0) {
+      return {
+        pid,
+        started_at: typeof raw.started_at === 'string' ? raw.started_at : null,
+        auto: raw.auto === true,
+        mode: typeof raw.mode === 'string' ? raw.mode : raw.auto === true ? 'auto' : 'manual',
+      };
+    }
+  } catch (e) {
+    // tidak ada / rusak → anggap tidak ada
+  }
+  return null;
+}
+
+function writePidInfo(info) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(PID_FILE, JSON.stringify(info, null, 2) + '\n');
+}
+
+function removePidInfo() {
+  try {
+    fs.unlinkSync(PID_FILE);
+  } catch (e) {
+    // sudah tidak ada → abaikan
+  }
+}
+
+// n baris terakhir log (null bila file belum ada)
+function tailLog(n) {
+  try {
+    const txt = fs.readFileSync(LOG_FILE, 'utf8');
+    const lines = txt.split(/\r?\n/);
+    while (lines.length && lines[lines.length - 1] === '') lines.pop();
+    return lines.slice(-Math.max(1, n));
+  } catch (e) {
+    return null;
+  }
+}
+
+function fmtUptime(ms) {
+  const total = Math.max(0, Math.floor(ms / 1000));
+  const d = Math.floor(total / 86400);
+  const h = Math.floor((total % 86400) / 3600);
+  const m = Math.floor((total % 3600) / 60);
+  const s = total % 60;
+  if (d > 0) return `${d}d ${h}j`;
+  if (h > 0) return `${h}j ${m}m`;
+  if (m > 0) return `${m}m ${s}s`;
+  return `${s}s`;
+}
+
 // Deteksi perubahan lebih luas dari updated_at saja: status, agent_status, note & waktu.
 function taskIdFingerprint(t) {
   return JSON.stringify([t.status || '', t.agent_status || '', t.agent_progress_note || '', t.agent_updated_at || '', t.updated_at || '', t.title || '']);
@@ -47,31 +146,56 @@ function printTaskLine(t, tag) {
   console.log(`${code}  ${trunc(t.title, 36)}  ${t.status || '-'}  ${tail}${stamp}`.replace(/\s+$/, ''));
 }
 
-function buildExecCommand(tpl, taskText) {
+// Masukkan satu tugas ke cache state; true bila berubah (sesuai fingerprint).
+function ingestTaskIntoState(t, state) {
+  const id = c.taskIdOf(t);
+  if (!id) return false;
+  const fp = taskIdFingerprint(t);
+  const cur = t.agent_updated_at || t.updated_at || null;
+  const prev = state.tasks[id];
+  const changed = !prev || prev.fp !== fp || (!prev.fp && prev.updated_at !== cur);
+  if (changed) state.tasks[id] = { updated_at: cur, fp, title: t.title, status: t.status };
+  return changed;
+}
+
+function buildExecCommand(tpl, taskText, rawModel) {
   if (!tpl || !tpl.includes('{task}')) return null;
+  let t = tpl;
+  if (t.includes('{model}')) {
+    // {model} diisi dari model provider (config/agent.command), fallback env LUANG_MODEL.
+    const model = String(rawModel || process.env.LUANG_MODEL || '').trim();
+    if (!model || !/^[\w.:+/-]+$/.test(model)) return null; // tanpa model → pemanggil menampilkan notifikasi
+    t = t.split('{model}').join(model);
+  }
   let q;
-  if (tpl.includes('"{task}"')) {
+  if (t.includes('"{task}"')) {
     q = taskText.replace(/(["`\\$])/g, '\\$1'); // escape untuk kutip ganda
-  } else if (tpl.includes("'{task}'")) {
+  } else if (t.includes("'{task}'")) {
     q = taskText.replace(/'/g, `'\\''`); // escape untuk kutip tunggal
   } else {
     q = taskText.replace(/(["`\\$\n])/g, ' '); // {task} tanpa kutip → rapikan
   }
-  return tpl.replaceAll('{task}', q);
+  return t.replaceAll('{task}', q);
 }
 
-function runExecChild(cmd, setChild) {
+function runExecChild(cmd, setChild, cwd) {
   const EXEC_TIMEOUT_MS = 15 * 60 * 1000; // exec dibatasi 15 menit agar daemon tidak menggantung
   return new Promise((resolve) => {
     let child = null;
     try {
-      child = exec(cmd, { maxBuffer: 8 * 1024 * 1024, timeout: EXEC_TIMEOUT_MS, windowsHide: true });
+      // stdio inherit → output provider (mis. "opencode run") tampil live di terminal.
+      // cwd = workspace folder (dashboard/CLI) bila valid, kalau tidak = cwd proses.
+      child = spawn(cmd, [], { shell: true, stdio: 'inherit', windowsHide: true, cwd: cwd || process.cwd() });
     } catch (e) {
       resolve(1);
       return;
     }
     if (setChild) setChild(child);
+    const killer = setTimeout(() => {
+      try { child.kill('SIGKILL'); } catch (e) { /* abaikan */ }
+    }, EXEC_TIMEOUT_MS);
     const fin = (code) => {
+      clearTimeout(killer);
       if (setChild) setChild(null);
       resolve(typeof code === 'number' ? code : 1);
     };
@@ -80,14 +204,135 @@ function runExecChild(cmd, setChild) {
   });
 }
 
-async function tryExecTask(rt, tasks, state, execCfg, current) {
+// ── Kanal transport ────────────────────────────────────────────────────────────
+// 'ws' → kirim via frame WS (task.status / command.ack / telemetry.run)
+// 'http' → perilaku lama: task status lewat POST /agent/tasks/:ref/status
+
+function makeConsent(cfg) {
+  return {
+    local: cfg.telemetry === true, // config.telemetry — opt-in lokal
+    server: null,                  // telemetry_enabled dari hello.ok (server)
+    noticed: false,
+  };
+}
+
+// Pemberitahuan konsent: sekali saja per sesi daemon (spek: never send + notice).
+function noticeConsentOnce(consent) {
+  if (consent.noticed) return;
+  consent.noticed = true;
+  const l = consent.local === true ? 'lokal ✅' : 'lokal ❌ (luang-cli telemetry on)';
+  const s =
+    consent.server === true
+      ? 'server ✅'
+      : consent.server === false
+        ? 'server ❌ (nyalakan Telemetry di dashboard Agents)'
+        : 'server ? (info belum diterima)';
+  console.log(`ℹ️  Telemetry TIDAK dikirim (${l} · ${s}) — consent ganda harus ON bersamaan.`);
+}
+
+function tokensMaybe(cfg) {
+  const out = {};
+  const pick = (envName, cfgVal) => {
+    const e = process.env[envName];
+    if (e !== undefined && String(e).trim() !== '') {
+      const n = Number(e);
+      if (Number.isFinite(n)) return n;
+    }
+    if (typeof cfgVal === 'number' && Number.isFinite(cfgVal)) return cfgVal;
+    return null;
+  };
+  const tin = pick('LUANG_TOKENS_IN', cfg.tokens_in);
+  const tout = pick('LUANG_TOKENS_OUT', cfg.tokens_out);
+  if (tin !== null) out.tokens_in = tin;
+  if (tout !== null) out.tokens_out = tout;
+  return out;
+}
+
+function makeChannel(kind, opts) {
+  const { rt, ws, consent } = opts;
+  const ch = {
+    kind,
+    rt,
+    ws,
+    consent,
+    paused: false, // dari agent.command pause/resume
+    latestTasks: [],
+    execChain: Promise.resolve(),
+    // Tugas yang sudah diberi tahu "eksekusi nonaktif" (sekali per sesi).
+    inactiveNotified: new Set(),
+    // Update status tugas; label dipakai untuk pesan error HTTP mode saja.
+    sendStatus(code, body, label) {
+      if (kind === 'ws' && this.ws) {
+        try {
+          this.ws.send({ type: 'task.status', ts: Date.now(), data: { ref: String(code), ...body } });
+        } catch (e) {
+          console.error(`⚠️  Gagal kirim task.status: ${e.message}`);
+        }
+        return;
+      }
+      apiRequest(this.rt, 'POST', `/api/v1/agent/tasks/${encodeURIComponent(String(code))}/status`, { body })
+        .catch((e) => console.error(`⚠️  Gagal ${label || 'update status tugas'}: ${e.message}`));
+    },
+    ack(commandId, ok, message) {
+      if (kind !== 'ws' || !this.ws) return;
+      const data = { command_id: commandId, ok: !!ok };
+      if (message) data.message = String(message);
+      try {
+        this.ws.send({ type: 'command.ack', ts: Date.now(), data });
+      } catch (e) {
+        console.error(`⚠️  Gagal kirim command.ack: ${e.message}`);
+      }
+    },
+    // Telemetry.run — HANYA realtime; tanpa consent → didrop di CLI + notice sekali.
+    telemetry(payload) {
+      if (kind !== 'ws') return;
+      if (!(consent.local === true && consent.server === true)) {
+        noticeConsentOnce(consent);
+        return;
+      }
+      try {
+        this.ws.send({ type: 'telemetry.run', ts: Date.now(), data: payload });
+      } catch (e) {
+        console.error(`⚠️  Gagal kirim telemetry.run: ${e.message}`);
+      }
+    },
+  };
+  return ch;
+}
+
+async function tryExecTask(ch, tasks, state, execCfg, current) {
+  if (ch.paused) return false; // di-pause server → exec tidak dijalankan
   const cand = tasks.find((t) => c.statusInputNorm(t.status) === 'todo' && !state.executed[c.taskIdOf(t)]);
   if (!cand) return false;
   const code = c.taskIdOf(cand);
+  if (!execCfg.doExec) {
+    // Eksekusi NONAKTIF (tanpa --exec / mode auto) → jangan salahkan
+    // exec_template; beri tahu cara menyalakannya. Tugas TIDAK ditandai
+    // executed, supaya nanti masih bisa jalan saat mode exec dinyalakan.
+    if (!ch.inactiveNotified.has(code)) {
+      ch.inactiveNotified.add(code);
+      console.log(
+        `⏭ ${code} menunggu (To-Do) — eksekusi nonaktif (jalankan \`luang-cli agent --exec\` atau \`agent start\` untuk mode otomatis).`,
+      );
+    }
+    return false;
+  }
   const taskText = `${cand.title || ''}${cand.description ? ' — ' + cand.description : ''}`;
-  const cmdStr = buildExecCommand(execCfg.template, taskText);
+  if (execCfg.template && execCfg.template.includes('{model}')) {
+    const model = String(execCfg.model || process.env.LUANG_MODEL || '').trim();
+    if (!model) {
+      // template memuat {model} tapi tidak ada model yang bisa dipakai → dilewati dengan notifikasi
+      state.executed[code] = true;
+      saveState(state);
+      console.log(
+        `⏭  ${code} menunggu (To-Do) — template memuat {model} tapi belum ada model. Set: provider add ${execCfg.type || '<type>'} --model <m>, server agent.command set_model, atau env LUANG_MODEL.`,
+      );
+      return true;
+    }
+  }
+  const cmdStr = buildExecCommand(execCfg.template, taskText, execCfg.model);
   if (!cmdStr) {
-    // exec_template kosong / tanpa {task} → hanya notifikasi satu baris (spec)
+    // HANYA saat exec aktif tapi template kosong/tanpa {task} → notifikasi (spec)
     state.executed[code] = true; // tandai agar tidak nag lagi
     saveState(state);
     console.log(
@@ -101,85 +346,379 @@ async function tryExecTask(rt, tasks, state, execCfg, current) {
   console.log(`🎯 Eksekusi tugas: ${code} — ${trunc(cand.title, 60)}`);
   console.log(`   Provider : ${execCfg.type}`);
   console.log(`   Perintah : ${trunc(cmdStr, 90)}`);
-  const ans = await c.ask('   Jalankan sekarang? (y/N) ');
+  // Workspace folder (dashboard/CLI): resolve + validasi; tidak valid → cwd proses + warning.
+  let execCwd = null;
+  const wsRaw = (ch.rt.cfg && ch.rt.cfg.workspace) || '';
+  if (String(wsRaw).trim()) {
+    const resolved = resolveWorkspace(wsRaw);
+    try {
+      const st = resolved && fs.statSync(resolved);
+      if (st && st.isDirectory()) {
+        execCwd = resolved;
+      } else {
+        console.log(`   ⚠️  Workspace "${wsRaw}" tidak ada/bukan folder — pakai folder saat ini.`);
+      }
+    } catch (e) {
+      console.log(`   ⚠️  Workspace "${wsRaw}" tak bisa diakses — pakai folder saat ini.`);
+    }
+  }
+  if (execCwd) console.log(`   Folder   : ${execCwd}`);
+  // Mode auto (agent start / --auto): TANPA konfirmasi — tidak ada terminal.
+  const ans = execCfg.auto ? 'y' : await c.ask('   Jalankan sekarang? (y/N) ');
+  if (execCfg.auto) console.log('   Konfirmasi: otomatis (mode auto, tanpa y/N).');
   state.executed[code] = true;
   if (ans !== 'y') {
     console.log('   Dilewati (tidak dijalankan).');
     saveState(state);
     return true;
   }
+  const model = String(execCfg.model || process.env.LUANG_MODEL || '') || undefined;
+  const toks = tokensMaybe(ch.rt.cfg);
+  const baseTel = { task_ref: code, task_code: code, provider: execCfg.type, model };
+  const t0 = Date.now();
   // Spesifikasi: sebelum eksekusi, tandai in_progress dengan agent_status "menjalankan".
-  try {
-    await apiRequest(rt, 'POST', `/api/v1/agent/tasks/${encodeURIComponent(code)}/status`, {
-      body: { status: 'in_progress', agent_status: 'menjalankan' },
-    });
-  } catch (e) {
-    console.error(`⚠️  Gagal set in_progress: ${e.message}`);
-  }
+  ch.sendStatus(code, { status: 'in_progress', agent_status: 'menjalankan' }, 'set in_progress');
+  ch.telemetry({ ...baseTel, status: 'started', ...toks });
   const exitCode = await runExecChild(cmdStr, (child) => {
     current.child = child;
-  });
+  }, execCwd);
   const ok = exitCode === 0;
   // Spesifikasi: exit 0 → {status:"done", agent_status:"selesai", progress_note:"exec exit 0"};
   // selain itu → {status:"review", agent_status:"gagal", progress_note:"exit code N"}.
+  ch.sendStatus(
+    code,
+    ok
+      ? { status: 'done', agent_status: 'selesai', progress_note: 'exec exit 0' }
+      : { status: 'review', agent_status: 'gagal', progress_note: `exit code ${exitCode}` },
+    'update status tugas',
+  );
+  ch.telemetry({
+    ...baseTel,
+    status: ok ? 'completed' : 'failed',
+    exit_code: exitCode,
+    duration_ms: Date.now() - t0,
+    ...toks,
+  });
+  console.log(ok ? `✅ ${code} selesai (exit 0)` : `⚠️  ${code} gagal (exit ${exitCode}) → review`);
+  return true;
+}
+
+// Rantai eksekusi: event datang serentak → anak antre, tidak dobel.
+function runExecMaybe(ch, state, execCfg, current) {
+  ch.execChain = ch.execChain
+    .then(() => tryExecTask(ch, ch.latestTasks, state, execCfg, current))
+    .then((acted) => {
+      if (acted) saveState(state);
+    })
+    .catch(() => {});
+  return ch.execChain;
+}
+
+// ── Encode waktu/config untuk WS ──────────────────────────────────────────────
+
+function wsRealtimeUrl(apiUrl) {
   try {
-    await apiRequest(rt, 'POST', `/api/v1/agent/tasks/${encodeURIComponent(code)}/status`, {
-      body: ok
-        ? { status: 'done', agent_status: 'selesai', progress_note: 'exec exit 0' }
-        : { status: 'review', agent_status: 'gagal', progress_note: `exit code ${exitCode}` },
-    });
+    const u = new URL(String(apiUrl));
+    if (u.protocol !== 'https:' && u.protocol !== 'http:') return null;
+    u.protocol = u.protocol === 'https:' ? 'wss:' : 'ws:';
+    let p = u.pathname.replace(/\/+$/, '');
+    p = p.endsWith('/api/v1') ? p + '/agent/ws' : p + '/api/v1/agent/ws';
+    u.pathname = p;
+    u.search = '';
+    return u.toString();
   } catch (e) {
-    console.error(`⚠️  Gagal update status tugas: ${e.message}`);
+    return null;
   }
-  console.log(ok ? `✅ ${code} selesai (exit 0)` : `⚠️  ${code} gagal (exit ${exitCode}) → review`);
-  return true;
 }
 
-async function cmdAgent(rt, args) {
-  if (!rt.key) return c.errExit('Belum login — jalankan `luang-cli login` atau set LUANG_KEY.');
-  const flags = args.flags;
-  let intervalSec = Number(flags.interval);
-  if (!intervalSec || intervalSec < 1) intervalSec = 5;
-  if (intervalSec > 3600) intervalSec = 3600;
-  const doExec = flags.exec === true;
+function canRealtime(rt) {
+  if (!wsLib) return false;
+  if (['1', 'true', 'yes'].includes(String(process.env.LUANG_NO_WS || '').toLowerCase())) return false;
+  return !!rt.key && !!wsRealtimeUrl(rt.apiUrl);
+}
 
-  const execCfg = { type: rt.cfg.default_provider, template: null };
-  if (doExec) {
-    const p = collectProviders(rt.cfg).find((x) => x.provider_type === rt.cfg.default_provider);
-    if (p && p.exec_template && p.exec_template.includes('{task}')) {
-      execCfg.template = p.exec_template;
+// providers untuk hello: kontrak WS pakai {type, exec_template?, model?, models?}
+function providersForHello(cfg) {
+  return collectProviders(cfg).map((p) => {
+    const o = { type: p.provider_type };
+    if (p.exec_template) o.exec_template = String(p.exec_template);
+    if (p.model) o.model = String(p.model);
+    // Kontrak baru (opsional): daftar model — maks 50 item × 120 karakter.
+    o.models = modelsForProvider(p.provider_type, { path: p.path }).models;
+    return o;
+  });
+}
+
+function hbIntervalMs() {
+  let s = Number(process.env.LUANG_HEARTBEAT_SEC);
+  if (!s || !Number.isFinite(s) || s < 3) s = 25; // WS default 25s (kontrak: ≤30s)
+  return Math.min(Math.floor(s), 60) * 1000;
+}
+
+// Sinkronkan execCfg ke provider default tertentu (dipakai hello.ok & agent.command
+// set_default_provider) — template & model diambil dari config provider tsb.
+function applyDefaultProvider(execCfg, cfg, type) {
+  execCfg.type = type;
+  const p = collectProviders(cfg).find((x) => x.provider_type === type);
+  execCfg.template = p ? p.exec_template || null : null;
+  execCfg.model = (p && p.model) || null;
+}
+
+// Baris "Eksekusi" di banner — pesan harus jujur sesuai mode:
+//   doExec=false → "nonaktif" (JANGAN menyalahkan exec_template);
+//   doExec=true tapi template kosong → baru menyebut exec_template.
+function execBanner(doExec, execCfg, auto) {
+  if (!doExec) return 'nonaktif';
+  if (!execCfg.template || !execCfg.template.includes('{task}')) {
+    return 'diminta tapi nonaktif — default provider belum punya exec_template berisi {task}';
+  }
+  const via = auto ? 'otomatis tanpa konfirmasi' : 'konfirmasi y/N';
+  return `aktif (${via} · ${execCfg.type || '-'}${execCfg.model ? ` · model ${execCfg.model}` : ''})`;
+}
+
+// agent.command dari server: set_model | set_default_provider | pause | resume → command.ack
+function handleAgentCommand(d, ctx) {
+  const { ch, rt, execCfg, state, current } = ctx;
+  const id = d.command_id || 'cmd';
+  const cmd = String(d.command || '').toLowerCase();
+  if (cmd === 'set_model') {
+    const type = d.provider || rt.cfg.default_provider;
+    const model = typeof d.model === 'string' ? d.model.trim() : '';
+    if (!type) {
+      ch.ack(id, false, 'Provider tidak diketahui & default provider belum di-set — jalankan: luang-cli provider default <type>');
+      return;
+    }
+    if (!model || !/^[\w.:+/-]+$/.test(model)) {
+      ch.ack(id, false, `Model tidak valid: ${JSON.stringify(d.model)}`);
+      return;
     }
+    const cur = (rt.cfg.providers && rt.cfg.providers[type]) || {};
+    rt.cfg.providers[type] = {
+      ...cur,
+      provider_type: type,
+      display_name: cur.display_name || DISPLAY_NAMES[type] || type,
+      model,
+    };
+    saveConfig(rt.cfg);
+    if (!execCfg.type || execCfg.type === type) execCfg.model = model;
+    console.log(`🎛  Perintah server: set_model → ${type} = ${model} (tersimpan)`);
+    ch.ack(id, true, `Model "${model}" tersimpan untuk provider ${type}`);
+    runExecMaybe(ch, state, execCfg, current); // tugas pending mungkin baru bisa jalan
+  } else if (cmd === 'set_default_provider') {
+    const type = typeof d.provider === 'string' ? d.provider.trim() : '';
+    if (!type) {
+      // Reset dari dashboard → kembali ke pilihan lokal CLI.
+      rt.cfg.default_provider = null;
+      saveConfig(rt.cfg);
+      console.log('🎛  Perintah server: default provider direset — memakai pilihan lokal CLI.');
+      ch.ack(id, true, 'default provider direset');
+      return;
+    }
+    const prev = rt.cfg.default_provider;
+    rt.cfg.default_provider = type;
+    saveConfig(rt.cfg);
+    if (!execCfg.type || execCfg.type === prev) applyDefaultProvider(execCfg, rt.cfg, type);
+    const known = collectProviders(rt.cfg).some((x) => x.provider_type === type);
+    console.log(`⭐ Perintah server: default provider → ${type} (tersimpan)`);
+    ch.ack(id, true, `default provider = ${type}${known ? '' : ' — provider belum ada di config lokal'}`);
+    runExecMaybe(ch, state, execCfg, current);
+  } else if (cmd === 'pause') {
+    ch.paused = true;
+    console.log('⏸  Perintah server: PAUSE — eksekusi ditunda (heartbeat tetap).');
+    ch.ack(id, true, 'paused');
+  } else if (cmd === 'resume') {
+    ch.paused = false;
+    console.log('▶️  Perintah server: RESUME — eksekusi tugas dilanjutkan.');
+    ch.ack(id, true, 'resumed');
+    runExecMaybe(ch, state, execCfg, current);
+  } else {
+    ch.ack(id, false, `Perintah tidak dikenal: ${cmd}`);
   }
+}
 
-  const state = loadState();
-  const current = { child: null };
-  let running = true;
+// ── Mode realtime (WS) ────────────────────────────────────────────────────────
 
-  console.log('🤖 Agent Luang aktif');
+function runAgentRealtime(rt, opts) {
+  const { execCfg, state, current, doExec } = opts;
+  const wsUrl = wsRealtimeUrl(rt.apiUrl);
+  if (!wsUrl) return Promise.resolve('fatal');
+  const ws = new wsLib.WsClient(wsUrl, { headers: { 'X-CLI-Key': rt.key } });
+  current.ws = ws;
+  const consent = makeConsent(rt.cfg);
+  const ch = makeChannel('ws', { rt, ws, consent });
+
+  console.log('🤖 Agent Luang aktif (realtime WebSocket)');
+  console.log(`   WS        : ${wsUrl}`);
   console.log(`   API       : ${rt.apiUrl}`);
-  console.log(`   Poll      : setiap ${intervalSec} detik · heartbeat setiap 30 detik`);
-  console.log(`   Eksekusi  : ${doExec ? (execCfg.template ? `aktif (${execCfg.type})` : 'diminta tapi nonaktif — default provider belum punya exec_template berisi {task}') : 'nonaktif'}`);
+  console.log(`   Heartbeat : frame tiap ≤30s (interval ${Math.round(hbIntervalMs() / 1000)}s)`);
+  console.log(`   Eksekusi  : ${execBanner(doExec, execCfg, execCfg.auto)}`);
+  console.log(`   Telemetry : ${consent.local === true ? 'config ON (butuh flag server ON juga)' : 'OFF (luang-cli telemetry on)'}`);
   console.log(`   State     : ${STATE_FILE}`);
-  console.log('   Hentikan  : Ctrl+C');
+  console.log(execCfg.auto ? '   Hentikan  : luang-cli agent stop (SIGTERM)' : '   Hentikan  : Ctrl+C');
   console.log('');
+  console.log('⏳ Menunggu handshake realtime…');
 
-  process.on('SIGINT', () => {
-    running = false;
-    if (current.child) {
+  return new Promise((resolve) => {
+    let settled = false;
+    let established = false;
+    let firstSync = true;
+    let hbTimer = null;
+
+    const settle = (v) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(guard);
+      if (hbTimer) {
+        clearInterval(hbTimer);
+        hbTimer = null;
+      }
+      if (v !== 'ok') ws.close(); // beres: jangan reconnect setelah fallback
+      resolve(v);
+    };
+
+    const guard = setTimeout(() => {
+      if (!established) settle('fallback');
+    }, REALTIME_GUARD_MS);
+
+    ws.on('open', () => {
       try {
-        current.child.kill('SIGINT');
+        ws.send({ type: 'hello', ts: Date.now(), data: { mode: 'cli', version: pkg.version, providers: providersForHello(rt.cfg) } });
       } catch (e) {
-        // abaikan
+        console.error(`⚠️  Gagal kirim hello: ${e.message}`);
       }
-    }
-    console.log('\n👋 Agent dihentikan.');
-    process.exit(0);
+      if (established) console.log(`🔌 WS terhubung ulang (${stampNow()}) — hello dikirim ulang`);
+    });
+    ws.on('reconnecting', ({ delay, reason }) => {
+      console.log(`🔁 WS terputus (${trunc(String(reason), 40)}) — mencoba ulang dalam ${(delay / 1000).toFixed(1)}s…`);
+    });
+    ws.on('error', () => {
+      // Gagal sambung sebelum/fallback cukup jelas dari fallback notice; setelah isi, event reconnects sudah dicetak.
+    });
+    ws.on('fatal', (e) => {
+      console.error(`❌ WS ditolak server: ${e.message}`);
+      settle('fatal');
+    });
+
+    hbTimer = setInterval(() => {
+      try {
+        ws.send({ type: 'heartbeat', ts: Date.now(), data: {} });
+      } catch (e) {
+        // ws lib mengantre saat reconnect; biarkan
+      }
+    }, hbIntervalMs());
+
+    ws.on('message', (raw) => {
+      let msg;
+      try {
+        msg = JSON.parse(raw);
+      } catch (e) {
+        return; // pesan invalid → abaikan (server yang benar tidak mengirim ini)
+      }
+      if (!msg || typeof msg.type !== 'string') return;
+      const d = msg.data && typeof msg.data === 'object' ? msg.data : {};
+      const ctx = { ch, rt, execCfg, state, current };
+
+      if (msg.type === 'hello.ok') {
+        consent.server = d.telemetry_enabled === true;
+        // Sinkron default provider pilihan dashboard → config lokal (saat beda).
+        const sdp = typeof d.default_provider === 'string' ? d.default_provider.trim() : '';
+        if (sdp && rt.cfg.default_provider !== sdp) {
+          const prev = rt.cfg.default_provider;
+          rt.cfg.default_provider = sdp;
+          saveConfig(rt.cfg);
+          if (!execCfg.type || execCfg.type === prev) applyDefaultProvider(execCfg, rt.cfg, sdp);
+          console.log(`⭐ Default provider sinkron dari dashboard: ${sdp}`);
+        }
+        // Sinkron workspace folder pilihan dashboard → config lokal (saat beda).
+        const sws = typeof d.workspace === 'string' ? d.workspace.trim() : '';
+        if (sws && rt.cfg.workspace !== sws) {
+          rt.cfg.workspace = sws;
+          saveConfig(rt.cfg);
+          console.log(`📁 Workspace sinkron dari dashboard: ${sws}`);
+        }
+        if (!established) {
+          established = true;
+          clearTimeout(guard);
+          console.log(`🔌 Realtime aktif · key #${d.key_id ?? '-'} · user #${d.user_id ?? '-'}${d.server_time ? ` · server_time ${d.server_time}` : ''}`);
+          console.log('   Event live: task.snapshot / task.assigned / task.updated · agent.command');
+          if (consent.local === true && consent.server === true) {
+            console.log('📈 Telemetry consent ON (lokal ✅ · server ✅) — event run dikirim realtime.');
+          } else {
+            noticeConsentOnce(consent);
+          }
+        }
+        return;
+      }
+      if (!established) return;
+
+      if (msg.type === 'task.snapshot') {
+        const tasks = c.normalizeTaskList(d);
+        let dirty = false;
+        const seen = new Set();
+        for (const t of tasks) {
+          const id = c.taskIdOf(t);
+          if (!id) continue;
+          seen.add(id);
+          if (ingestTaskIntoState(t, state)) {
+            dirty = true;
+            printTaskLine(t, firstSync ? 'sinkron awal' : 'berubah');
+          }
+        }
+        for (const id of Object.keys(state.tasks)) {
+          if (!seen.has(id)) {
+            delete state.tasks[id];
+            dirty = true;
+          }
+        }
+        firstSync = false;
+        ch.latestTasks = tasks;
+        if (dirty) saveState(state);
+        runExecMaybe(ch, state, execCfg, current);
+      } else if (msg.type === 'task.updated' || msg.type === 'task.assigned') {
+        const t = d.task && typeof d.task === 'object' ? d.task : d.id ? d : null;
+        if (!t) return;
+        if (ingestTaskIntoState(t, state)) {
+          printTaskLine(t, msg.type === 'task.assigned' ? 'di-assign' : 'berubah');
+          saveState(state);
+        }
+        const id = c.taskIdOf(t);
+        const i = ch.latestTasks.findIndex((x) => c.taskIdOf(x) === id);
+        if (i >= 0) ch.latestTasks[i] = t;
+        else ch.latestTasks.push(t);
+        runExecMaybe(ch, state, execCfg, current);
+      } else if (msg.type === 'agent.command') {
+        handleAgentCommand(d, ctx);
+      } else if (msg.type === 'error') {
+        console.error(`⚠️  WS server error: ${d.code || '-'} ${trunc(String(d.message || ''), 120)}`);
+      }
+      // heartbeat / agent.online / lainnya diabaikan (bukan untuk CLI)
+    });
+
+    ws.connect();
   });
+}
+
+// ── Mode polling (fallback, perilaku lama) ───────────────────────────────────
+
+async function runAgentPolling(rt, opts) {
+  const { intervalSec, doExec, execCfg, state, current } = opts;
+  const ch = makeChannel('http', { rt });
+  let running = true;
+
+  console.log('🤖 Agent Luang aktif');
+  console.log(`   API       : ${rt.apiUrl}`);
+  console.log(`   Poll      : setiap ${intervalSec} detik · heartbeat setiap 30 detik`);
+  console.log('   Realtime  : nonaktif — polling HTTP (WS gagal/dimatikan)');
+  console.log('   Telemetry : tidak dikirim (mode polling tanpa kanal realtime)');
+  console.log(`   Eksekusi  : ${execBanner(doExec, execCfg, execCfg.auto)}`);
+  console.log(`   State     : ${STATE_FILE}`);
+  console.log(execCfg.auto ? '   Hentikan  : luang-cli agent stop (SIGTERM)' : '   Hentikan  : Ctrl+C');
+  console.log('');
 
   const heartbeat = async (label) => {
     try {
       await apiRequest(rt, 'POST', '/api/v1/agent/heartbeat', {
-        body: { providers: core.heartbeatProviders(collectProviders(rt.cfg)) },
+        body: { providers: heartbeatProviders(collectProviders(rt.cfg)) },
       });
       console.log(`📡 ${label} terkirim`);
     } catch (e) {
@@ -187,24 +726,26 @@ async function cmdAgent(rt, args) {
     }
   };
 
-  const hbInterval = setInterval(() => {
+  let hbTimer = setInterval(() => {
     if (running) heartbeat('Heartbeat');
-  }, 30000);
+  }, hbIntervalSec() * 1000);
 
   let first = true;
-  while (running) {
+  let runningLoop = true;
+  while (runningLoop) {
     let tasks;
     try {
       const res = await apiRequest(rt, 'GET', '/api/v1/agent/tasks');
       tasks = c.normalizeTaskList(res);
     } catch (e) {
       if (e instanceof ApiError && (e.status === 401 || e.status === 403)) {
-        clearInterval(hbInterval);
+        clearInterval(hbTimer);
+        runningLoop = false;
         console.error(`❌ Key ditolak server (HTTP ${e.status}): ${e.message}`);
         console.error('   Cek: luang-cli whoami · login ulang: luang-cli login');
         return 1;
       }
-      console.error(`⚠️  Poll gagal: ${e.message} — coba lagi dalam ${intervalSec} detik…`);
+      console.log(`⚠️  Poll gagal: ${e.message} — coba lagi dalam ${intervalSec} detik…`);
       await sleep(intervalSec * 1000);
       continue;
     }
@@ -215,21 +756,11 @@ async function cmdAgent(rt, args) {
       const id = c.taskIdOf(t);
       if (!id) continue;
       seen.add(id);
-      const cur = t.agent_updated_at || t.updated_at || null;
-      const fp = taskIdFingerprint(t);
-      const prev = state.tasks[id];
-      // berubah bila tidak ada cache, atau fingerprint (status/agent_status/note/waktu) berbeda
-      const changed =
-        !prev ||
-        prev.fp !== fp ||
-        (!prev.fp && prev.updated_at !== cur);
-      if (changed) {
-        state.tasks[id] = { updated_at: cur, fp, title: t.title, status: t.status };
+      if (ingestTaskIntoState(t, state)) {
         dirty = true;
         printTaskLine(t, first ? 'baru dipantau' : 'berubah');
       }
     }
-    // bersihkan cache untuk tugas yang tak lagi dikirim server
     for (const id of Object.keys(state.tasks)) {
       if (!seen.has(id)) {
         delete state.tasks[id];
@@ -238,15 +769,256 @@ async function cmdAgent(rt, args) {
     }
     first = false;
     if (dirty) saveState(state);
+    ch.latestTasks = tasks;
 
-    if (doExec) {
-      const acted = await tryExecTask(rt, tasks, state, execCfg, current);
-      if (acted) saveState(state);
-    }
+    // Sama seperti mode realtime: cek eksekusi tiap siklus (notice "eksekusi
+    // nonaktif" dicetak bila doExec=false; eksekusi jalan hanya bila doExec).
+    runExecMaybe(ch, state, execCfg, current);
 
     await sleep(intervalSec * 1000);
   }
-  clearInterval(hbInterval);
+  clearInterval(hbTimer);
+  return 0;
+}
+
+function hbIntervalSec() {
+  let s = Number(process.env.LUANG_HEARTBEAT_SEC);
+  if (!s || !Number.isFinite(s) || s < 3) s = 30; // HTTP polling: 30s (perilaku lama)
+  return Math.min(Math.floor(s), 3600);
+}
+
+async function cmdAgent(rt, args) {
+  // Subcommand background: agent start | stop | status | logs.
+  const sub = args.pos[1];
+  if (sub === 'start') return agentStart(rt, args);
+  if (sub === 'stop') return agentStop(rt, args);
+  if (sub === 'status') return agentStatus(rt, args);
+  if (sub === 'logs') return agentLogs(rt, args);
+  if (sub !== undefined && !String(sub).startsWith('-')) {
+    console.error(`❌ Sub-command agent tidak dikenal: ${sub}`);
+    console.error('   Gunakan: (foreground) --exec | --auto · atau start | stop | status | logs');
+    console.error('   Bantuan: luang-cli help agent');
+    return 1;
+  }
+
+  if (!rt.key) return c.errExit('Belum login — jalankan `luang-cli login` atau set LUANG_KEY.');
+  const flags = args.flags;
+  let intervalSec = Number(flags.interval);
+  if (!intervalSec || intervalSec < 1) intervalSec = 5;
+  if (intervalSec > 3600) intervalSec = 3600;
+  // --auto (dipakai anak proses `agent start`): doExec=true TANPA y/N karena
+  // tidak ada terminal. Foreground `agent` / `agent --exec` tetap perilaku lama.
+  const auto = flags.auto === true;
+  const doExec = flags.exec === true || auto;
+
+  const execCfg = { type: rt.cfg.default_provider, template: null, model: null, doExec, auto };
+  if (doExec) {
+    // Selalu isi dari collectProviders (baik flag --exec maupun mode auto).
+    const p = collectProviders(rt.cfg).find((x) => x.provider_type === rt.cfg.default_provider);
+    if (p) {
+      execCfg.template = p.exec_template || null;
+      execCfg.model = p.model || null;
+    }
+  }
+
+  const state = loadState();
+  const current = { child: null, ws: null };
+
+  // Ctrl+C (SIGINT) dan `agent stop` (SIGTERM) memakai jalur yang sama.
+  const shutdown = () => {
+    if (current.child) {
+      try {
+        current.child.kill('SIGINT');
+      } catch (e) {
+        // abaikan
+      }
+    }
+    if (current.ws) {
+      try {
+        current.ws.close();
+      } catch (e) {
+        // abaikan
+      }
+    }
+    console.log('\n👋 Agent dihentikan.');
+    process.exit(0);
+  };
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // 1) Realtime WebSocket — enhancement, bukan syarat (kontrak §5).
+  if (canRealtime(rt)) {
+    const mode = await runAgentRealtime(rt, { doExec, execCfg, state, current });
+    if (mode === 'ok') return 0; // sampai Ctrl+C (process.exit pada handler)
+    console.log('');
+    if (mode === 'fatal') {
+      console.log('❌ Server menolak/menyediakan WS — beralih ke fallback polling HTTP.');
+    } else {
+      console.log('⚠️  WS gagal terhubung dalam batas waktu — beralih ke fallback polling HTTP.');
+    }
+    console.log('');
+  } else if (!wsLib) {
+    console.log('⚠️  lib/ws tidak tersedia di Node ini — beralih ke fallback polling HTTP.');
+    console.log('');
+  }
+
+  // 2) Fallback polling HTTP klasik.
+  return runAgentPolling(rt, { intervalSec, doExec, execCfg, state, current });
+}
+
+// ── agent start | stop | status | logs (daemon di background) ────────────────
+
+// Mulai agent sebagai proses TERPISAH (detached): output → ~/.luang-cli/agent.log,
+// pid → ~/.luang-cli/agent.pid (JSON {pid, started_at, auto, mode}).
+async function agentStart(rt, args) {
+  if (!rt.key) return c.errExit('Belum login — jalankan `luang-cli login` atau set LUANG_KEY.');
+  const flags = args.flags;
+  // Default `agent start` = mode auto; `--no-auto` mematikan (monitor saja).
+  const auto = flags['no-auto'] !== true;
+  rt.cfg.auto_exec = auto;
+  saveConfig(rt.cfg);
+
+  const existing = readPidInfo();
+  if (existing && isPidAlive(existing.pid)) {
+    console.log(`ℹ️  Agent sudah berjalan (pid ${existing.pid}${existing.auto ? ' · mode auto' : ' · mode manual'}) · log: ${tildePath(LOG_FILE)}`);
+    console.log('   Hentikan dulu: luang-cli agent stop');
+    return 0;
+  }
+  if (existing) removePidInfo(); // pid basi (prosesnya sudah mati)
+
+  const childArgs = ['agent'];
+  if (auto) childArgs.push('--auto');
+  if (flags.api !== undefined && flags.api !== true) childArgs.push('--api', String(flags.api));
+  if (flags.interval !== undefined && flags.interval !== true) childArgs.push('--interval', String(flags.interval));
+
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  const fd = fs.openSync(LOG_FILE, 'a');
+  let child;
+  try {
+    child = spawn(process.execPath, [BIN, ...childArgs], {
+      detached: true,
+      stdio: ['ignore', fd, fd],
+      env: process.env,
+      cwd: process.cwd(),
+      windowsHide: true,
+    });
+  } catch (e) {
+    fs.closeSync(fd);
+    return c.errExit(`Gagal spawn proses agent: ${e.message}`);
+  }
+  fs.closeSync(fd);
+  if (!child || !child.pid) return c.errExit('Gagal spawn proses agent (pid tidak ada).');
+  child.unref();
+
+  const info = {
+    pid: child.pid,
+    started_at: new Date().toISOString(),
+    auto,
+    mode: auto ? 'auto' : 'manual',
+  };
+  writePidInfo(info);
+  console.log(`🚀 Agent berjalan di background (pid ${child.pid}) · log: ${tildePath(LOG_FILE)}`);
+  console.log(`   Mode : ${auto ? 'auto (eksekusi tugas To-Do tanpa konfirmasi y/N)' : 'manual (eksekusi nonaktif)'}`);
+
+  // Pastikan anak tidak langsung mati (mis. gagal start) — bukan sekadar asumsi.
+  await sleep(700);
+  if (!isPidAlive(child.pid)) {
+    const tail = tailLog(6) || [];
+    console.error('❌ Proses agent keluar segera setelah start — cek log:');
+    for (const l of tail) console.error('   | ' + l);
+    removePidInfo();
+    return 1;
+  }
+  return 0;
+}
+
+// Hentikan agent background: SIGTERM (graceful), handle bila sudah mati.
+async function agentStop() {
+  const info = readPidInfo();
+  if (!info) {
+    console.log('ℹ️  Agent tidak berjalan (tidak ada ~/.luang-cli/agent.pid).');
+    return 0;
+  }
+  if (!isPidAlive(info.pid)) {
+    removePidInfo();
+    console.log(`ℹ️  Proses ${info.pid} sudah mati — agent.pid dibersihkan.`);
+    return 0;
+  }
+  try {
+    process.kill(info.pid, 'SIGTERM');
+  } catch (e) {
+    if (e && (e.code === 'ESRCH' || e.code === 'ENOENT')) {
+      removePidInfo();
+      console.log(`ℹ️  Proses ${info.pid} sudah mati — agent.pid dibersihkan.`);
+      return 0;
+    }
+    return c.errExit(`Gagal mengirim SIGTERM ke pid ${info.pid}: ${e.message}`);
+  }
+  let dead = false;
+  for (let i = 0; i < 50; i++) {
+    if (!isPidAlive(info.pid)) {
+      dead = true;
+      break;
+    }
+    await sleep(100);
+  }
+  if (!dead) {
+    console.error(`⚠️  Pid ${info.pid} belum mati setelah 5 detik (SIGTERM) — coba lagi, cek log: ${tildePath(LOG_FILE)}`);
+    return 1;
+  }
+  removePidInfo();
+  console.log(`✅ Agent (pid ${info.pid}) dihentikan (SIGTERM, graceful).`);
+  return 0;
+}
+
+// Status: pid, uptime, mode auto/manual, config auto_exec, 3 baris log terakhir.
+async function agentStatus(rt) {
+  console.log('🔎 Agent status');
+  const autoCfg = rt.cfg.auto_exec === true ? 'true' : 'false';
+  const info = readPidInfo();
+  if (!info) {
+    console.log('   Proses         : ❌ tidak berjalan (tidak ada agent.pid)');
+    console.log(`   Auto exec      : config auto_exec = ${autoCfg}`);
+    console.log(`   Log            : ${tildePath(LOG_FILE)}${fs.existsSync(LOG_FILE) ? '' : ' (belum ada)'}`);
+    console.log('   Mulai          : luang-cli agent start');
+    return 0;
+  }
+  const alive = isPidAlive(info.pid);
+  console.log(`   PID            : ${info.pid} (${alive ? 'hidup ✅' : 'mati ❌ — pid file basi'})`);
+  let startedMs = info.started_at ? Date.parse(info.started_at) : NaN;
+  if (!Number.isFinite(startedMs)) {
+    try {
+      startedMs = fs.statSync(PID_FILE).mtimeMs; // fallback: mtime pid file
+    } catch (e) {
+      startedMs = NaN;
+    }
+  }
+  console.log(`   Uptime         : ${Number.isFinite(startedMs) ? fmtUptime(Date.now() - startedMs) : '-'} (mulai ${info.started_at || '-'})`);
+  console.log(`   Mode           : ${info.auto ? 'auto (otomatis tanpa konfirmasi)' : 'manual (eksekusi nonaktif)'}`);
+  console.log(`   Auto exec      : config auto_exec = ${autoCfg}`);
+  console.log(`   Log            : ${tildePath(LOG_FILE)}`);
+  const lines = tailLog(3);
+  if (lines && lines.length) {
+    console.log('   ── log (3 terakhir) ──');
+    for (const l of lines) console.log('   ' + l);
+  } else {
+    console.log('   (log kosong / belum ada)');
+  }
+  if (!alive) console.log('   Bersihkan      : luang-cli agent stop');
+  return 0;
+}
+
+// Tail log agent (default 30 baris).
+async function agentLogs(rt, args) {
+  let n = Number(args.flags.tail);
+  if (!Number.isFinite(n) || n < 1) n = 30;
+  n = Math.min(Math.floor(n), 5000);
+  const lines = tailLog(n);
+  if (!lines) {
+    console.log(`ℹ️  Log belum ada: ${tildePath(LOG_FILE)}`);
+    return 0;
+  }
+  for (const l of lines) console.log(l);
   return 0;
 }
 
@@ -383,18 +1155,34 @@ async function cmdStatus(rt) {
     console.log('   ➡️  Mulai: luang-cli login');
     return 0;
   }
+  let d = null;
   try {
     const me = await apiRequest(rt, 'GET', '/api/v1/agent/me');
-    const d = (me && me.data) || {};
+    d = (me && me.data) || {};
     console.log(`   Sesi : ${d.name || '-'} (${d.key_id || 'key-?'}) · status ${d.status || '-'}`);
     console.log(`   Tenant: ${d.tenant_slug || d.tenant_id || '-'}`);
     console.log(`   Izin : update-tugas ${d.can_update_tasks ? '✅' : '❌'} · buat-tugas ${d.can_create_tasks ? '✅' : '❌'}`);
+    console.log(`   Telemetry: ${c.telemetryConsentLabel(rt.cfg.telemetry === true, d.telemetry_enabled === true)} (ubah lokal: telemetry on|off)`);
     console.log(`   Provider server: ${c.providersLabel(d.providers)}`);
   } catch (e) {
     console.log(`   ⚠️  /me gagal: ${e.message}`);
+    console.log(`   Telemetry: ${c.telemetryConsentLabel(rt.cfg.telemetry === true, null)}`);
+  }
+  // Sinkron default provider dari dashboard (field server, kosong = tak diset).
+  const sdp = typeof (d && d.default_provider) === 'string' ? d.default_provider.trim() : '';
+  if (sdp && rt.cfg.default_provider !== sdp) {
+    rt.cfg.default_provider = sdp;
+    saveConfig(rt.cfg);
+  }
+  // Sinkron workspace folder dari dashboard (field server, kosong = tak diset).
+  const sws = typeof (d && d.workspace) === 'string' ? d.workspace.trim() : '';
+  if (sws && rt.cfg.workspace !== sws) {
+    rt.cfg.workspace = sws;
+    saveConfig(rt.cfg);
   }
   const list = collectProviders(rt.cfg);
-  console.log(`   Default provider: ${rt.cfg.default_provider || '(belum di-set)'}`);
+  console.log(`   Default provider: ${rt.cfg.default_provider || '(belum di-set)'}${sdp ? ' ⭐ disetel dashboard' : ''}`);
+  console.log(`   Workspace: ${rt.cfg.workspace || '(folder saat ini)'}${sws ? ' 📁 disetel dashboard' : ''}`);
   console.log(`   Provider lokal  : ${list.length ? list.map((p) => (p.is_default ? '★' + p.provider_type : p.provider_type)).join(', ') : '(tidak ada)'}`);
   console.log(`   Config/state    : ${CONFIG_DIR.replace(process.env.HOME || '~', '~')}`);
   return 0;
@@ -422,4 +1210,4 @@ async function cmdMcpConfig(rt) {
   return 0;
 }
 
-module.exports = { cmdAgent, cmdTask, cmdStatus, cmdMcpConfig, buildExecCommand, runExecChild };
+module.exports = { cmdAgent, cmdTask, cmdStatus, cmdMcpConfig, buildExecCommand, runExecChild, wsRealtimeUrl, canRealtime, providersForHello, hbIntervalMs, makeChannel, handleAgentCommand, ingestTaskIntoState };