@mazees/mark 5.0.0

package/src/renderer/src/api/subagent/subagentPrompt.js

@@ -0,0 +1,44 @@
+/**
+ * Generator System Prompt untuk Sub-Agent MARK V5
+ * Murni utilitarian, berorientasi hasil, tanpa beban persona/obrolan santai.
+ * Seluruh schema tool telah diinjeksi langsung secara native via OpenAPI Function Definitions.
+ */
+export function buildSubagentSystemPrompt({ role, goal }) {
+  return `Kamu adalah SUB-AGENT SPESIALIS otonom dalam sistem MARK (Metacognitive Artificial Relational Knowledge).
+Kamu bekerja di lingkungan terisolasi untuk mengeksekusi misi teknis yang didelegasikan langsung oleh LEAD AGENT (MARK), CREATOR / USER, atau SESAMA SUB-AGENT.
+
+# IDENTITAS & MISI:
+- Role: ${role || 'Technical Specialist'}
+- Goal: ${goal || 'Selesaikan misi teknis yang diberikan secara tuntas'}
+
+# ATURAN KERJA UTAMA (AUTONOMOUS REACT LOOP):
+1. **LAKUKAN AKSI NYATA TERLEBIH DAHULU (TOOLS FIRST)**:
+   - DILARANG KERAS LANGSUNG MENJAWAB TEKS DI GILIRAN PERTAMA JIKA TUGAS ADALAH RISET, PENELITIAN, ANALISIS DATA, ATAU CODING.
+   - Panggil native tool yang relevan untuk mengumpulkan fakta nyata atau memodifikasi sistem sebelum menarik kesimpulan.
+   - **ALUR RISET WEB TERPERCAYA & BATCH PARALLEL**:
+     1. Panggil 'browser-search' (query: "kata kunci") HANYA untuk menemukan daftar URL / link sumber. Tool ini BUKAN untuk membaca isi artikel!
+     2. Setelah menemukan daftar link dari 'browser-search', SANGAT DIANJURKAN memanggil beberapa 'browser-fetch' sekaligus (2-4 URL berbeda) dalam SATU GILIRAN (Batch / Parallel Tool Calls). Jangan mengambil satu per satu jika bisa dibaca serentak!
+     3. Gunakan 'browser-navigate' HANYA jika halaman web membutuhkan interaksi fisik (klik tombol, form login, atau rendering JavaScript kompleks).
+2. **KONTROL BROWSER & WEB OTONOM**:
+   - Kamu memiliki akses tool web lengkap:
+     * 'browser-search' (query: "..."): Menemukan daftar link/URL web teratas.
+     * 'browser-fetch' (url: "..."): Membaca dan mengambil (curl/fetch) isi konten teks artikel secara cepat.
+     * 'browser-navigate' (url: "..."): Membuka halaman web di browser fisik untuk interaksi tombol/form.
+     * 'browser-read': Membaca elemen DOM halaman browser fisik saat ini.
+     * 'browser-click' (element_id: ...): Mengklik link atau tombol di browser fisik.
+     * 'browser-scroll' (direction: "down"): Men-scroll halaman browser fisik.
+     * 'browser-extract' (selector: "..."): Mengekstrak konten via CSS selector.
+3. **PARALLEL & BATCH ACTIONS**:
+   - Jika kamu perlu membaca beberapa berkas ('read-file') atau mengambil konten banyak URL ('browser-fetch'), kirim seluruh tool calls sekaligus dalam satu turn.
+   - Untuk form input, kirim 'browser-click' dan 'browser-type' secara bersamaan.
+4. **KOMUNIKASI ANTAR SUB-AGENT ('message_agent')**:
+   - Jika kamu membutuhkan data, konfirmasi, atau bantuan dari sub-agent lain (contoh: @Researcher, @Mr Tester, @Developer), panggil tool 'message_agent' (target_agent: "nama_agen", message: "instruksi").
+   - Jawaban dari sub-agent target akan kembali ke observasimu untuk kamu analisis lebih lanjut.
+5. **LAPORAN AKHIR KE LEAD AGENT ('report_to_lead')**:
+   - Panggil 'report_to_lead' atau berikan jawaban final HANYA jika seluruh rangkaian aksi, observasi tool, dan koordinasi SUDAH SELESAI 100%. Sertakan sumber URL dan data konkret yang ditemukan.
+6. **DILARANG BERBASA-BASI**: Jangan menyapa santai ("Halo", "Siap boss"). Langsung eksekusi tool atau laporkan temuan teknis yang solid.
+7. **BACA SEBELUM MENULIS**: Sebelum memodifikasi atau menimpa berkas kode, kamu WAJIB membaca isi berkas tersebut via 'read-file' terlebih dahulu.
+8. **ANTI-HALUSINASI (ZERO HALLUCINATION)**: Dilarang mengarang data statistik, link, atau isi file yang belum pernah diobservasi melalui tool.`
+    .replace(/\n{3,}/g, '\n\n')
+    .trim()
+}

package/src/renderer/src/api/subagent/subagentStore.js

@@ -0,0 +1,173 @@
+import { db } from '../db'
+
+// Set untuk melacak ID sub-agent yang sedang/telah dihapus guna mencegah race condition pada update async
+const deletedSubagentIds = new Set()
+
+export const subagentStore = {
+  /**
+   * Cek apakah subagent ID sedang atau telah dihapus
+   */
+  isDeleted(id) {
+    return deletedSubagentIds.has(id)
+  },
+
+  /**
+   * Membuat entitas Sub-Agent baru di database SQLite (Unique Name Aware)
+   * Jika sudah ada subagent dengan nama yang sama (case-insensitive):
+   * - Jika statusnya 'running', kembalikan instance yang sedang berjalan (tidak membuat duplikat).
+   * - Jika statusnya 'idle', 'completed', 'killed', atau 'failed', aktifkan kembali dengan goal baru.
+   */
+  async createSubagent({
+    name = 'Specialist-Agent',
+    role = 'Technical Specialist',
+    goal = 'Selesaikan misi yang ditugaskan',
+    allowedTools = ['*'],
+    parentSessionId = '1',
+    parentSessionTitle = 'Main Thread',
+    forceNew = false
+  }) {
+    const trimmedName = (name || 'Specialist-Agent').trim()
+    const normalizedName = trimmedName.replace(/^@/, '')
+
+    // Cek keberadaan subagent dengan nama yang sama agar entitas selalu unik
+    if (!forceNew) {
+      const existingAgents = await this.listSubagents('all')
+      const existing = existingAgents.find(
+        (s) =>
+          s.name.toLowerCase().trim() === trimmedName.toLowerCase() ||
+          s.name.toLowerCase().replace(/^@/, '').trim() === normalizedName.toLowerCase()
+      )
+
+      if (existing) {
+        // Jika sudah ada dan sedang berjalan, jangan spawn baru, pakai yang ada
+        if (existing.status === 'running') {
+          return { ...existing, isExisting: true, wasRunning: true }
+        }
+
+        // Jika sudah ada tapi sedang idle / stop, perbarui info dan hidupkan kembali
+        const updates = {
+          role: role || existing.role || 'Technical Specialist',
+          goal: goal || existing.goal,
+          allowedTools: allowedTools && allowedTools.length > 0 ? allowedTools : existing.allowedTools,
+          status: 'running',
+          parentSessionId: String(parentSessionId || existing.parentSessionId || '1'),
+          parentSessionTitle:
+            parentSessionTitle ||
+            existing.parentSessionTitle ||
+            (String(parentSessionId) === '1' ? 'Main Thread' : `Sesi #${parentSessionId}`),
+          updatedAt: Date.now()
+        }
+        await this.updateSubagent(existing.id, updates)
+        return { ...existing, ...updates, isExisting: true, wasRunning: false }
+      }
+    }
+
+    const id = `sub_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`
+    deletedSubagentIds.delete(id)
+    const subagent = {
+      id,
+      name: trimmedName,
+      role,
+      goal,
+      allowedTools,
+      status: 'running',
+      parentSessionId: String(parentSessionId || '1'),
+      parentSessionTitle: parentSessionTitle || (String(parentSessionId) === '1' ? 'Main Thread' : `Sesi #${parentSessionId}`),
+      turnCount: 0,
+      createdAt: Date.now(),
+      updatedAt: Date.now(),
+      finalAnswer: null
+    }
+    await db.subagents.put(subagent)
+    return subagent
+  },
+
+  /**
+   * Mengambil metadata Sub-Agent berdasarkan ID
+   */
+  async getSubagent(id) {
+    if (!id || deletedSubagentIds.has(id)) return null
+    return await db.subagents.get(id)
+  },
+
+  /**
+   * Mengambil daftar seluruh Sub-Agent
+   */
+  async listSubagents(filterStatus = null) {
+    let collection = db.subagents.orderBy('createdAt').reverse()
+    let list = []
+    if (filterStatus && filterStatus !== 'all') {
+      list = await collection.filter((s) => s.status === filterStatus).toArray()
+    } else {
+      list = await collection.toArray()
+    }
+    return (list || []).filter((s) => s && s.id && !deletedSubagentIds.has(s.id))
+  },
+
+  /**
+   * Mengupdate field/status Sub-Agent
+   */
+  async updateSubagent(id, updates) {
+    if (!id || deletedSubagentIds.has(id)) return
+    const existing = await db.subagents.get(id)
+    if (!existing || deletedSubagentIds.has(id)) return
+    await db.subagents.update(id, { ...updates, updatedAt: Date.now() })
+  },
+
+  /**
+   * Menghapus Sub-Agent beserta riwayat chat-nya
+   */
+  async deleteSubagent(id) {
+    if (!id) return
+    deletedSubagentIds.add(id)
+    try {
+      const { killSubagentExecution } = await import('./subagentExecutor')
+      killSubagentExecution(id, true)
+    } catch (_) {}
+    try {
+      await db.subagents.delete(id)
+    } catch (err) {
+      console.error('[subagentStore] Error deleting subagent from DB:', err)
+    }
+    try {
+      await db.subagent_messages.where('subagentId').equals(id).delete()
+    } catch (_) {}
+  },
+
+  /**
+   * Menambahkan pesan ke riwayat percakapan AI-to-AI Sub-Agent
+   */
+  async addMessage(subagentId, { sender, role, content, thought = null, action = null, tool_calls = null, tool_call_id = null, name = null }) {
+    if (!subagentId || deletedSubagentIds.has(subagentId)) return null
+    const msg = {
+      subagentId,
+      sender, // 'mark' | 'subagent' | 'user' | 'system' | 'tool'
+      role, // 'user' | 'assistant' | 'system' | 'tool'
+      content: typeof content === 'string' ? content : (content ? JSON.stringify(content) : ''),
+      thought: thought || null,
+      action: action || null,
+      tool_calls: tool_calls || null,
+      tool_call_id: tool_call_id || null,
+      name: name || null,
+      timestamp: Date.now()
+    }
+    const id = await db.subagent_messages.add(msg)
+    return { ...msg, id }
+  },
+
+  /**
+   * Mengambil semua pesan Sub-Agent secara kronologis
+   */
+  async getMessages(subagentId) {
+    if (!subagentId || deletedSubagentIds.has(subagentId)) return []
+    return await db.subagent_messages.where('subagentId').equals(subagentId).sortBy('timestamp')
+  },
+
+  /**
+   * Membersihkan pesan dari satu Sub-Agent
+   */
+  async clearMessages(subagentId) {
+    if (!subagentId) return
+    await db.subagent_messages.where('subagentId').equals(subagentId).delete()
+  }
+}

package/src/renderer/src/api/taskExecutor.js

@@ -0,0 +1,18 @@
+import { getAgentTaskContentHash, validateAgentTaskStepOutput } from './taskStore'
+
+// Executor helper hanya menentukan hasil checkpoint; eksekusi tool tetap berada di ReAct loop utama.
+export function buildDurableStepCheckpoint(step, output, maxRetries = 2) {
+  const validation = validateAgentTaskStepOutput(step, output)
+  const attempts = step?.attempts || 0
+  const canRetry = !validation.isComplete && attempts < maxRetries + 1
+
+  return {
+    status: validation.isComplete ? 'completed' : canRetry ? 'needs_revision' : 'failed',
+    outputSummary: String(output || '').slice(0, 1200),
+    contentHash: getAgentTaskContentHash(output),
+    artifactPath: step?.artifactPath || null,
+    validation,
+    error: validation.isComplete || canRetry ? null : 'Validasi step gagal setelah batas retry.',
+    canRetry
+  }
+}

package/src/renderer/src/api/taskStore.js

@@ -0,0 +1,315 @@
+import { db } from './db'
+
+export const TASK_STATUSES = [
+  'pending',
+  'running',
+  'paused',
+  'waiting_user',
+  'failed',
+  'completed',
+  'cancelled'
+]
+export const STEP_STATUSES = [
+  'pending',
+  'running',
+  'needs_revision',
+  'completed',
+  'failed',
+  'skipped'
+]
+const now = () => Date.now()
+
+// Hash ringan dipakai untuk mendeteksi output identik tanpa menyimpan isi besar di Dexie.
+export function getAgentTaskContentHash(value = '') {
+  const text = String(value)
+  let hash = 2166136261
+  for (let index = 0; index < text.length; index += 1) {
+    hash ^= text.charCodeAt(index)
+    hash = Math.imul(hash, 16777619)
+  }
+  return (hash >>> 0).toString(16).padStart(8, '0')
+}
+
+function makeId(prefix) {
+  const uuid = globalThis.crypto?.randomUUID?.()
+  return prefix + '-' + (uuid || now() + '-' + Math.random().toString(36).slice(2, 10))
+}
+
+function assertTaskStatus(status) {
+  if (!TASK_STATUSES.includes(status)) throw new Error('Invalid task status: ' + status)
+}
+
+function assertStepStatus(status) {
+  if (!STEP_STATUSES.includes(status)) throw new Error('Invalid step status: ' + status)
+}
+
+// Validasi lokal menjaga checkpoint tetap deterministik tanpa menambah panggilan AI.
+export function validateAgentTaskStepOutput(step = {}, output = '') {
+  const text = typeof output === 'string' ? output.trim() : ''
+  const hasContent = text.length >= (step.acceptanceCriteria?.length ? 80 : 20)
+  return {
+    isComplete: hasContent,
+    score: hasContent ? 1 : 0,
+    missingRequirements: hasContent ? [] : ['Output step terlalu pendek atau kosong.'],
+    notes: hasContent
+      ? 'Validasi dasar konten berhasil.'
+      : 'Step perlu diulang karena deliverable belum memiliki isi yang cukup.'
+  }
+}
+
+export async function createAgentTask(input = {}) {
+  // Create task dan semua step dalam satu transaksi supaya outline tidak setengah jadi.
+  const timestamp = now()
+  const taskId = input.id || makeId('task')
+  const steps = (input.steps || []).map((step, index) => ({
+    id:
+      step.id && step.id.startsWith(taskId + '-')
+        ? step.id
+        : taskId + '-' + (step.id || 'step-' + (index + 1)),
+    taskId,
+    stepIndex: index,
+    index,
+    title: step.title || 'Step ' + (index + 1),
+    objective: step.objective || '',
+    deliverable: step.deliverable || '',
+    acceptanceCriteria: step.acceptanceCriteria || [],
+    status: step.status || (index === 0 ? 'running' : 'pending'),
+    inputSummary: step.inputSummary || '',
+    outputSummary: step.outputSummary || '',
+    artifactPath: step.artifactPath || null,
+    validation: step.validation || null,
+    contentHash: step.contentHash || null,
+    attempts: 0,
+    startedAt: null,
+    completedAt: null,
+    updatedAt: timestamp,
+    error: null
+  }))
+  const task = {
+    id: taskId,
+    title: input.title || 'MARK Task',
+    objective: input.objective || '',
+    mode: input.mode || 'durable',
+    status: input.status || (steps.length ? 'running' : 'failed'),
+    currentStepIndex: input.currentStepIndex ?? 0,
+    activeStepId: input.activeStepId || steps[0]?.id || null,
+    constraints: input.constraints || {},
+    contextSummary: input.contextSummary || '',
+    artifactRoot: input.artifactRoot || null,
+    retryCount: input.retryCount || 0,
+    maxRetries: input.maxRetries ?? 2,
+    createdAt: timestamp,
+    updatedAt: timestamp,
+    completedAt: null,
+    error: steps.length ? null : 'Task harus memiliki minimal satu step'
+  }
+  await db.transaction('rw', db.agentTasks, db.agentTaskSteps, async () => {
+    await db.agentTasks.add(task)
+    if (steps.length) await db.agentTaskSteps.bulkAdd(steps)
+  })
+  return task
+}
+
+export async function getAgentTask(taskId) {
+  return db.agentTasks.get(taskId)
+}
+
+export async function getAgentTaskWithSteps(taskId) {
+  const task = await db.agentTasks.get(taskId)
+  if (!task) return null
+
+  let steps = []
+  try {
+    steps = await db.agentTaskSteps.where('taskId').equals(taskId).toArray()
+  } catch (err) {
+    void err
+    try {
+      const res = await fetch(`/api/tasks/${taskId}/steps`).then((r) => r.json())
+      if (res?.data) steps = res.data
+    } catch (e) {
+      console.warn('[taskStore] Failed to fetch task steps:', e)
+    }
+  }
+
+  steps.sort((a, b) => {
+    const idxA = a.stepIndex ?? a.step_index ?? a.index ?? 0
+    const idxB = b.stepIndex ?? b.step_index ?? b.index ?? 0
+    return idxA - idxB
+  })
+
+  return { ...task, steps }
+}
+
+export async function listAgentTasks({ status, limit = 50 } = {}) {
+  const collection = status
+    ? db.agentTasks.where('status').equals(status).reverse()
+    : db.agentTasks.orderBy('updatedAt').reverse()
+  return collection.limit(limit).toArray()
+}
+
+export async function updateAgentTask(taskId, changes = {}) {
+  if (changes.status) assertTaskStatus(changes.status)
+  await db.agentTasks.update(taskId, { ...changes, updatedAt: now() })
+  return getAgentTask(taskId)
+}
+
+export async function updateAgentTaskStep(stepId, changes = {}) {
+  if (changes.status) assertStepStatus(changes.status)
+  await db.agentTaskSteps.update(stepId, { ...changes, updatedAt: now() })
+  return db.agentTaskSteps.get(stepId)
+}
+
+export async function startAgentTask(taskId) {
+  return updateAgentTask(taskId, { status: 'running', error: null })
+}
+
+// Resume hanya membuka kembali task paused dan mengaktifkan step pointer terakhir.
+export async function resumeAgentTask(taskId) {
+  const task = await getAgentTaskWithSteps(taskId)
+  if (!task) throw new Error('Task tidak ditemukan')
+  if (!['paused', 'pending'].includes(task.status)) {
+    throw new Error('Task tidak bisa di-resume dari status ' + task.status)
+  }
+  if (!task.activeStepId) return updateAgentTask(taskId, { status: 'completed', error: null })
+  return startAgentTaskStep(taskId, task.activeStepId)
+}
+
+// Retry manual mengulang step failed/needs_revision dengan batas yang sama seperti executor.
+export async function retryAgentTaskStep(taskId, stepId) {
+  const task = await getAgentTaskWithSteps(taskId)
+  const step = task?.steps?.find((item) => item.id === stepId)
+  if (!task || !step) throw new Error('Task step tidak ditemukan')
+  if (!['failed', 'needs_revision'].includes(step.status)) {
+    throw new Error('Step belum berada pada status retryable')
+  }
+  if ((step.attempts || 0) >= (task.maxRetries || 2) + 1) {
+    throw new Error('Batas retry step sudah tercapai')
+  }
+  return startAgentTaskStep(taskId, stepId)
+}
+
+export async function startAgentTaskStep(taskId, stepId) {
+  // Step aktif ditandai running saat executor mulai memproses step itu.
+  const timestamp = now()
+  return db.transaction('rw', db.agentTasks, db.agentTaskSteps, async () => {
+    const step = await db.agentTaskSteps.get(stepId)
+    const currentTaskId = step?.taskId || step?.task_id
+    if (!step || (currentTaskId && currentTaskId !== taskId))
+      throw new Error('Task step tidak ditemukan')
+    await db.agentTaskSteps.update(stepId, {
+      status: 'running',
+      attempts: (step.attempts || 0) + 1,
+      startedAt: step.startedAt || timestamp,
+      error: null,
+      updatedAt: timestamp
+    })
+    await db.agentTasks.update(taskId, {
+      status: 'running',
+      activeStepId: stepId,
+      currentStepIndex: step.stepIndex ?? step.step_index ?? step.index ?? 0,
+      updatedAt: timestamp
+    })
+    return db.agentTaskSteps.get(stepId)
+  })
+}
+
+export async function checkpointAgentTaskStep(taskId, stepId, checkpoint = {}) {
+  // Checkpoint ini menyimpan hasil step dan memajukan pointer ke step pending berikutnya.
+  const timestamp = now()
+  return db.transaction('rw', db.agentTasks, db.agentTaskSteps, async () => {
+    const step = await db.agentTaskSteps.get(stepId)
+    const task = await db.agentTasks.get(taskId)
+    const currentTaskId = step?.taskId || step?.task_id
+    if (!step || (currentTaskId && currentTaskId !== taskId) || !task)
+      throw new Error('Task checkpoint tidak ditemukan')
+    if (checkpoint.status) assertStepStatus(checkpoint.status)
+    await db.agentTaskSteps.update(stepId, {
+      ...checkpoint,
+      updatedAt: timestamp,
+      ...(checkpoint.status === 'completed'
+        ? { completedAt: checkpoint.completedAt || timestamp }
+        : {})
+    })
+    const taskChanges = { updatedAt: timestamp }
+    if (checkpoint.status === 'completed') {
+      let allSteps = []
+      try {
+        allSteps = await db.agentTaskSteps.where('taskId').equals(taskId).toArray()
+      } catch (err) {
+        void err
+      }
+      if (!allSteps || allSteps.length === 0) {
+        try {
+          const res = await fetch(`/api/tasks/${taskId}/steps`).then((r) => r.json())
+          if (res?.data) allSteps = res.data
+        } catch (e) {
+          void e
+        }
+      }
+      const next = (allSteps || [])
+        .filter((item) => item.id !== stepId && ['pending', 'needs_revision'].includes(item.status))
+        .sort(
+          (a, b) =>
+            (a.stepIndex ?? a.step_index ?? a.index ?? 0) -
+            (b.stepIndex ?? b.step_index ?? b.index ?? 0)
+        )[0]
+      taskChanges.activeStepId = next?.id || null
+      taskChanges.active_step_id = next?.id || null
+      taskChanges.currentStepIndex =
+        next?.stepIndex ??
+        next?.step_index ??
+        next?.index ??
+        step.stepIndex ??
+        step.step_index ??
+        step.index ??
+        0
+      if (!next) {
+        taskChanges.status = 'completed'
+        taskChanges.completedAt = timestamp
+        taskChanges.activeStepId = null
+        taskChanges.active_step_id = null
+      }
+    }
+    await db.agentTasks.update(taskId, taskChanges)
+    return getAgentTaskWithSteps(taskId)
+  })
+}
+
+export async function transitionAgentTask(taskId, status, error = null) {
+  assertTaskStatus(status)
+  return updateAgentTask(taskId, {
+    status,
+    error,
+    ...(status === 'completed' ? { completedAt: now() } : {})
+  })
+}
+
+export async function pauseStaleAgentTasks(reason = 'app_restart') {
+  // Saat app hidup lagi, task yang masih running diparkir dulu agar tidak dianggap selesai.
+  const active = await db.agentTasks.where('status').anyOf(['running', 'waiting_user']).toArray()
+  if (!active.length) return 0
+  const timestamp = now()
+  await db.transaction('rw', db.agentTasks, async () => {
+    await Promise.all(
+      active.map((task) =>
+        db.agentTasks.update(task.id, {
+          status: 'paused',
+          error: reason,
+          updatedAt: timestamp
+        })
+      )
+    )
+  })
+  return active.length
+}
+
+export async function cancelAgentTask(taskId) {
+  return transitionAgentTask(taskId, 'cancelled', 'cancelled_by_user')
+}
+
+export async function deleteAgentTask(taskId) {
+  await db.transaction('rw', db.agentTasks, db.agentTaskSteps, async () => {
+    await db.agentTaskSteps.where('taskId').equals(taskId).delete()
+    await db.agentTasks.delete(taskId)
+  })
+}