luang-cli 0.3.0 → 0.3.2

package/lib/agent.js

@@ -5,6 +5,8 @@
 // Bagian lanjutan dari lib/commands.js.
 
 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.
@@ -25,10 +27,12 @@ const {
   saveConfig,
   collectProviders,
   heartbeatProviders,
+  resolveWorkspace,
   DEFAULT_TEMPLATES,
   DISPLAY_NAMES,
   STATE_FILE,
   CONFIG_DIR,
+  modelsForProvider,
   fmtWhen,
   keyPrefix,
   trunc,
@@ -41,6 +45,11 @@ const STATUS_LABELS = { todo: 'To-Do', in_progress: 'In Progress', review: 'Revi
 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() {
@@ -49,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 || '']);
@@ -95,13 +178,14 @@ function buildExecCommand(tpl, taskText, rawModel) {
   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 {
       // stdio inherit → output provider (mis. "opencode run") tampil live di terminal.
-      child = spawn(cmd, [], { shell: true, stdio: 'inherit', windowsHide: true });
+      // 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;
@@ -174,6 +258,8 @@ function makeChannel(kind, opts) {
     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) {
@@ -219,6 +305,18 @@ async function tryExecTask(ch, tasks, state, execCfg, current) {
   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 : ''}`;
   if (execCfg.template && execCfg.template.includes('{model}')) {
     const model = String(execCfg.model || process.env.LUANG_MODEL || '').trim();
@@ -234,7 +332,7 @@ async function tryExecTask(ch, tasks, state, execCfg, current) {
   }
   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(
@@ -248,7 +346,26 @@ async function tryExecTask(ch, 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).');
@@ -264,7 +381,7 @@ async function tryExecTask(ch, tasks, state, execCfg, current) {
   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"}.
@@ -320,12 +437,14 @@ function canRealtime(rt) {
   return !!rt.key && !!wsRealtimeUrl(rt.apiUrl);
 }
 
-// providers untuk hello: kontrak WS pakai {type, exec_template?, model?}
+// 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;
   });
 }
@@ -336,7 +455,28 @@ function hbIntervalMs() {
   return Math.min(Math.floor(s), 60) * 1000;
 }
 
-// agent.command dari server: set_model | pause | resume → command.ack
+// 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';
@@ -364,6 +504,24 @@ function handleAgentCommand(d, ctx) {
     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).');
@@ -393,10 +551,10 @@ function runAgentRealtime(rt, opts) {
   console.log(`   WS        : ${wsUrl}`);
   console.log(`   API       : ${rt.apiUrl}`);
   console.log(`   Heartbeat : frame tiap ≤30s (interval ${Math.round(hbIntervalMs() / 1000)}s)`);
-  console.log(`   Eksekusi  : ${doExec ? (execCfg.template ? `aktif (${execCfg.type}${execCfg.model ? ` · model ${execCfg.model}` : ''})` : 'diminta tapi nonaktif — default provider belum punya exec_template berisi {task}') : 'nonaktif'}`);
+  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…');
 
@@ -462,6 +620,22 @@ function runAgentRealtime(rt, opts) {
 
       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);
@@ -536,9 +710,9 @@ async function runAgentPolling(rt, opts) {
   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  : ${doExec ? (execCfg.template ? `aktif (${execCfg.type})` : 'diminta tapi nonaktif — default provider belum punya exec_template berisi {task}') : 'nonaktif'}`);
+  console.log(`   Eksekusi  : ${execBanner(doExec, execCfg, execCfg.auto)}`);
   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('');
 
   const heartbeat = async (label) => {
@@ -597,10 +771,9 @@ async function runAgentPolling(rt, opts) {
     if (dirty) saveState(state);
     ch.latestTasks = tasks;
 
-    if (doExec) {
-      const acted = await tryExecTask(ch, 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);
   }
@@ -615,24 +788,44 @@ function hbIntervalSec() {
 }
 
 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;
-  const doExec = flags.exec === true;
+  // --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 };
+  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 && p.exec_template && p.exec_template.includes('{task}')) execCfg.template = p.exec_template;
-    if (p && p.model) execCfg.model = p.model;
+    if (p) {
+      execCfg.template = p.exec_template || null;
+      execCfg.model = p.model || null;
+    }
   }
 
   const state = loadState();
   const current = { child: null, ws: null };
 
-  process.on('SIGINT', () => {
+  // Ctrl+C (SIGINT) dan `agent stop` (SIGTERM) memakai jalur yang sama.
+  const shutdown = () => {
     if (current.child) {
       try {
         current.child.kill('SIGINT');
@@ -649,7 +842,9 @@ async function cmdAgent(rt, args) {
     }
     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)) {
@@ -671,6 +866,162 @@ async function cmdAgent(rt, args) {
   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;
+}
+
 // ── task list / create / status ──────────────────────────────────────────────
 
 async function cmdTaskList(rt, args) {
@@ -817,8 +1168,21 @@ async function cmdStatus(rt) {
     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;