kiosapi 0.1.28 → 0.1.29

package/dist/agent/mcp.js

@@ -0,0 +1,205 @@
+/**
+ * MCP (Model Context Protocol) client — stdio transport only.
+ *
+ * Protocol: newline-delimited JSON-RPC 2.0 over child process stdin/stdout.
+ * No external SDK needed — the protocol is simple enough to implement directly.
+ */
+import { spawn } from 'node:child_process';
+import { VERSION } from '../help.js';
+// ---------------------------------------------------------------------------
+// Single server connection
+// ---------------------------------------------------------------------------
+class McpConnection {
+    serverName;
+    proc;
+    buffer = '';
+    pending = new Map();
+    nextId = 1;
+    dead = false;
+    constructor(serverName, config) {
+        this.serverName = serverName;
+        const env = { ...process.env, ...(config.env ?? {}) };
+        // On Windows, npx/npm commands need shell:true to resolve correctly
+        const needsShell = process.platform === 'win32' &&
+            (config.command === 'npx' || config.command === 'npm' || config.command === 'node');
+        this.proc = spawn(config.command, config.args ?? [], {
+            env,
+            stdio: ['pipe', 'pipe', 'pipe'], // capture stderr so it doesn't pollute CLI output
+            shell: needsShell,
+        });
+        this.proc.stdout?.setEncoding('utf8');
+        this.proc.stdout?.on('data', (chunk) => {
+            this.buffer += chunk;
+            const lines = this.buffer.split('\n');
+            this.buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const msg = JSON.parse(line);
+                    if (msg.id !== undefined) {
+                        const p = this.pending.get(msg.id);
+                        if (p) {
+                            clearTimeout(p.timer);
+                            this.pending.delete(msg.id);
+                            if (msg.error) {
+                                p.reject(new Error(msg.error.message));
+                            }
+                            else {
+                                p.resolve(msg.result);
+                            }
+                        }
+                    }
+                }
+                catch {
+                    // non-JSON line (debug output, etc.) — ignore
+                }
+            }
+        });
+        const onExit = () => {
+            this.dead = true;
+            for (const p of this.pending.values()) {
+                clearTimeout(p.timer);
+                p.reject(new Error(`MCP server "${this.serverName}" exited unexpectedly`));
+            }
+            this.pending.clear();
+        };
+        this.proc.on('exit', onExit);
+        this.proc.on('error', onExit);
+    }
+    write(msg) {
+        this.proc.stdin?.write(`${JSON.stringify(msg)}\n`);
+    }
+    request(method, params, timeoutMs = 30_000) {
+        return new Promise((resolve, reject) => {
+            if (this.dead) {
+                reject(new Error(`MCP server "${this.serverName}" is not running`));
+                return;
+            }
+            const id = this.nextId++;
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`MCP "${this.serverName}" timeout after ${timeoutMs}ms`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve: (r) => resolve(r), reject, timer });
+            this.write({ jsonrpc: '2.0', id, method, params });
+        });
+    }
+    async initialize() {
+        await this.request('initialize', {
+            protocolVersion: '2024-11-05',
+            clientInfo: { name: 'kiosapi', version: VERSION },
+            capabilities: { tools: {} },
+        }, 10_000);
+        // Notification — no response expected
+        this.write({ jsonrpc: '2.0', method: 'notifications/initialized' });
+    }
+    async listTools() {
+        const result = await this.request('tools/list', {}, 10_000);
+        return result.tools ?? [];
+    }
+    async callTool(name, args) {
+        const result = await this.request('tools/call', { name, arguments: args }, 60_000);
+        const content = result.content ?? [];
+        const text = content
+            .filter((c) => c.type === 'text' && c.text)
+            .map((c) => c.text ?? '')
+            .join('\n');
+        if (result.isError)
+            throw new Error(`MCP tool error: ${text}`);
+        return text || '(no output)';
+    }
+    kill() {
+        this.dead = true;
+        try {
+            this.proc.kill();
+        }
+        catch {
+            // already dead
+        }
+    }
+    get isAlive() {
+        return !this.dead;
+    }
+}
+// ---------------------------------------------------------------------------
+// Manager: multiple servers, unified tool registry
+// ---------------------------------------------------------------------------
+function sanitizeName(s) {
+    return s.replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+export class McpManager {
+    connections = new Map();
+    registry = [];
+    /**
+     * Connect to all configured servers in parallel. Failures are logged but do not abort — a
+     * partially-connected MCP set is better than no MCP at all.
+     */
+    async connect(servers, onWarn) {
+        const entries = Object.entries(servers);
+        const results = await Promise.allSettled(entries.map(async ([name, config]) => {
+            const conn = new McpConnection(name, config);
+            await conn.initialize();
+            const tools = await conn.listTools();
+            this.connections.set(name, conn);
+            for (const tool of tools) {
+                const qualifiedName = `mcp__${sanitizeName(name)}__${sanitizeName(tool.name)}`;
+                this.registry.push({
+                    qualifiedName,
+                    serverName: name,
+                    toolName: tool.name,
+                    spec: {
+                        type: 'function',
+                        function: {
+                            name: qualifiedName,
+                            description: `[MCP:${name}] ${tool.description ?? tool.name}`,
+                            parameters: tool.inputSchema,
+                        },
+                    },
+                });
+            }
+        }));
+        for (const [i, result] of results.entries()) {
+            if (result.status === 'rejected') {
+                const serverName = entries[i]?.[0] ?? '?';
+                onWarn?.(`⚠ MCP server "${serverName}" gagal: ${result.reason.message}`);
+            }
+        }
+    }
+    /** ToolSpec[] for all connected MCP tools — merged into the agent's tool list. */
+    getToolSpecs() {
+        return this.registry.map((r) => r.spec);
+    }
+    /** Dispatch a tool call by qualified name. */
+    async callTool(qualifiedName, args) {
+        const entry = this.registry.find((r) => r.qualifiedName === qualifiedName);
+        if (!entry)
+            throw new Error(`MCP tool "${qualifiedName}" tidak dikenal`);
+        const conn = this.connections.get(entry.serverName);
+        if (!conn?.isAlive)
+            throw new Error(`MCP server "${entry.serverName}" tidak aktif`);
+        return conn.callTool(entry.toolName, args);
+    }
+    get toolCount() {
+        return this.registry.length;
+    }
+    get serverCount() {
+        return this.connections.size;
+    }
+    /** Summary of servers and their tool counts — for display. */
+    summary() {
+        const byServer = new Map();
+        for (const r of this.registry) {
+            if (!byServer.has(r.serverName))
+                byServer.set(r.serverName, []);
+            byServer.get(r.serverName).push(r);
+        }
+        return [...byServer.entries()].map(([server, tools]) => ({ server, tools }));
+    }
+    disconnect() {
+        for (const conn of this.connections.values())
+            conn.kill();
+        this.connections.clear();
+        this.registry = [];
+    }
+}

package/dist/agent/run.js

@@ -1,8 +1,9 @@
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { extname, join } from 'node:path';
 import { chatComplete, generateImage, resolveMediaModel, streamVision, } from '../api.js';
-import { CHECKPOINT_PATH } from '../config.js';
+import { CHECKPOINT_PATH, loadMcpServers } from '../config.js';
 import { cyan, dim, green, idn, prompt, red, rupiah, thinking, yellow } from '../ui.js';
+import { McpManager } from './mcp.js';
 import { systemPrompt, toolsForMode } from './schemas.js';
 import { bacaFile, cari, daftarFile, editFile, hapusFile, jalankan, pindahFile, safePath, tulisFile, } from './tools.js';
 const MAX_STEPS = 50;
@@ -61,6 +62,7 @@ function trimContext(messages) {
     const droppedHead = clean.slice(0, clean.length - tail.length + skip);
     const droppedPaths = [];
     const droppedDirs = [];
+    const droppedModified = [];
     for (const msg of droppedHead) {
         if (msg.role === 'assistant' && msg.tool_calls) {
             for (const tc of msg.tool_calls) {
@@ -76,6 +78,13 @@ function trimContext(messages) {
                 }
             }
         }
+        // Track files that were successfully written/edited/deleted in the dropped context so the
+        // model knows it already made those changes and shouldn't repeat them after trimming.
+        if (msg.role === 'tool' && msg.content) {
+            const m = msg.content.match(/^OK:\s+(.+?)\s+(dibuat|diubah|dihapus|dipindah)/);
+            if (m?.[1])
+                droppedModified.push(m[1]);
+        }
     }
     const filesNote = droppedPaths.length > 0
         ? ` File sudah dibaca: ${[...new Set(droppedPaths)].join(', ')}. JANGAN baca ulang — gunakan cari untuk teks spesifik.`
@@ -83,9 +92,12 @@ function trimContext(messages) {
     const dirsNote = droppedDirs.length > 0
         ? ` Direktori sudah terdaftar: ${[...new Set(droppedDirs)].join(', ')}. JANGAN list ulang — gunakan baca_file untuk file spesifik.`
         : '';
+    const modifiedNote = droppedModified.length > 0
+        ? ` File sudah dimodifikasi: ${[...new Set(droppedModified)].join(', ')}. JANGAN tulis ulang kecuali ada perubahan tambahan.`
+        : '';
     const note = {
         role: 'system',
-        content: `[Kiosapi: ${dropped} pesan awal dihapus dari konteks.${filesNote}${dirsNote}]`,
+        content: `[Kiosapi: ${dropped} pesan awal dihapus dari konteks.${filesNote}${dirsNote}${modifiedNote}]`,
     };
     return [system, note, ...tail];
 }
@@ -476,7 +488,8 @@ export async function runTurn(s, userText) {
         }
     }
     s.messages.push({ role: 'user', content: userText });
-    const tools = toolsForMode(s.mode);
+    s._lastCompleted = false;
+    const tools = [...toolsForMode(s.mode), ...(s.mcpManager?.getToolSpecs() ?? [])];
     let lastText = '';
     let totalIn = 0;
     let totalOut = 0;
@@ -572,7 +585,14 @@ export async function runTurn(s, userText) {
             const total = callCounts.get(loopSig) ?? 0;
             console.log(red(`\n⚠ Loop terdeteksi: "${loopName}" dipanggil ${total}× — agen terjebak.`));
             console.log(yellow('Berikan instruksi baru, atau ketik /bersih untuk mulai ulang.'));
-            const loopMsg = `⚠ LOOP: "${loopName}" sudah dipanggil ${total}× dengan argumen yang sama. JANGAN panggil lagi. Gunakan tool "selesai" dan jelaskan kendalanya, atau minta klarifikasi dari pengguna.`;
+            const loopMsg = `⚠ LOOP TERDETEKSI: "${loopName}" sudah dipanggil ${total}× — BERHENTI SEKARANG.
+
+Panggil tool "selesai" dengan ringkasan yang berisi:
+1. Apa yang SUDAH berhasil dikerjakan (file diubah, perintah dijalankan)
+2. Apa yang BELUM selesai dan kendala yang ditemui
+3. Saran langkah berikutnya untuk pengguna
+
+JANGAN panggil tool lain selain "selesai".`;
             for (const call of calls) {
                 s.messages.push({ role: 'tool', content: loopMsg, tool_call_id: call.id });
             }
@@ -615,6 +635,45 @@ export async function runTurn(s, userText) {
                 s.messages.push({ role: 'tool', content: warn, tool_call_id: call.id });
                 continue;
             }
+            // MCP tool dispatch — routed to the connected MCP server
+            if (call.function.name.startsWith('mcp__') && s.mcpManager) {
+                let mcpArgs = {};
+                try {
+                    mcpArgs = JSON.parse(call.function.arguments || '{}');
+                }
+                catch {
+                    s.messages.push({
+                        role: 'tool',
+                        content: 'Error: argumen bukan JSON valid.',
+                        tool_call_id: call.id,
+                    });
+                    continue;
+                }
+                const [, serverPart, ...toolParts] = call.function.name.split('__');
+                console.log(dim(`  mcp:${serverPart} → ${toolParts.join('__')}`));
+                if (!(await allow(s.otomatis, `Jalankan MCP tool "${call.function.name}"?`))) {
+                    s.messages.push({
+                        role: 'tool',
+                        content: 'Ditolak oleh pengguna.',
+                        tool_call_id: call.id,
+                    });
+                    continue;
+                }
+                let mcpOut;
+                try {
+                    mcpOut = await s.mcpManager.callTool(call.function.name, mcpArgs);
+                }
+                catch (err) {
+                    mcpOut = `Error MCP: ${err instanceof Error ? err.message : String(err)}`;
+                }
+                const MAX_STORED_RESULT_MCP = 10_000;
+                const stored = mcpOut.length > MAX_STORED_RESULT_MCP
+                    ? `${mcpOut.slice(0, MAX_STORED_RESULT_MCP)}\n…[dipotong]`
+                    : mcpOut;
+                s.messages.push({ role: 'tool', content: stored, tool_call_id: call.id });
+                saveCheckpoint(s);
+                continue;
+            }
             const result = await runTool(call, s.otomatis, s.model);
             // Cap what goes into the conversation history: full output can be 300 lines of directory
             // listing or 100 KB of file content, which quickly overflows small-context-window models
@@ -644,6 +703,7 @@ export async function runTurn(s, userText) {
                 console.log(green(`\n✓ Selesai: ${result.output}`));
                 showUsage();
                 s.totalTokens += totalIn + totalOut;
+                s._lastCompleted = true;
                 clearCheckpoint();
                 return result.output;
             }
@@ -662,5 +722,19 @@ export async function runTurn(s, userText) {
 }
 /** One-shot: run a single task in a mode (used by the `rencana`/`edit`/`buat` subcommands). */
 export async function runAgent(task, mode, opts) {
-    await runTurn(newSession(opts.model, mode, opts.otomatis), task);
+    const s = newSession(opts.model, mode, opts.otomatis);
+    const mcpServers = loadMcpServers();
+    let mcpManager;
+    if (Object.keys(mcpServers).length > 0) {
+        mcpManager = new McpManager();
+        await mcpManager.connect(mcpServers);
+        if (mcpManager.toolCount > 0)
+            s.mcpManager = mcpManager;
+    }
+    try {
+        await runTurn(s, task);
+    }
+    finally {
+        mcpManager?.disconnect();
+    }
 }

package/dist/agent/skills.js

@@ -0,0 +1,84 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { SKILLS_GLOBAL_DIR, projectSkillsDir } from '../config.js';
+function parseFrontmatter(content) {
+    if (!content.startsWith('---\n'))
+        return { meta: {}, body: content.trim() };
+    const end = content.indexOf('\n---\n', 4);
+    if (end === -1)
+        return { meta: {}, body: content.trim() };
+    const raw = content.slice(4, end);
+    const meta = {};
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('#'))
+            continue;
+        const match = trimmed.match(/^(\w+):\s*(.*)$/);
+        if (match?.[1])
+            meta[match[1]] = match[2]?.trim() ?? '';
+    }
+    return { meta, body: content.slice(end + 5).trim() };
+}
+function readSkillFile(filePath, source) {
+    try {
+        const content = readFileSync(filePath, 'utf8');
+        const { meta, body } = parseFrontmatter(content);
+        const name = filePath.split(/[/\\]/).pop()?.replace(/\.md$/, '') ?? '';
+        if (!name || !body)
+            return null;
+        const modeRaw = meta.mode ?? 'buat';
+        const mode = modeRaw === 'rencana' || modeRaw === 'edit' ? modeRaw : 'buat';
+        return {
+            name,
+            description: meta.description ?? '',
+            prompt: body,
+            mode,
+            otomatis: meta.otomatis === 'true',
+            model: meta.model || undefined,
+            source,
+            filePath,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/** Load a skill by name: project (.kiosapi/skills/) overrides global (~/.kiosapi/skills/). */
+export function loadSkill(name) {
+    const projectPath = join(projectSkillsDir(), `${name}.md`);
+    if (existsSync(projectPath))
+        return readSkillFile(projectPath, 'project');
+    const globalPath = join(SKILLS_GLOBAL_DIR, `${name}.md`);
+    if (existsSync(globalPath))
+        return readSkillFile(globalPath, 'global');
+    return null;
+}
+/** List all available skills (project overrides global on name collision). */
+export function listSkills() {
+    const skills = new Map();
+    // Load global first so project can override
+    for (const { dir, source } of [
+        { dir: SKILLS_GLOBAL_DIR, source: 'global' },
+        { dir: projectSkillsDir(), source: 'project' },
+    ]) {
+        if (!existsSync(dir))
+            continue;
+        try {
+            for (const file of readdirSync(dir)) {
+                if (!file.endsWith('.md'))
+                    continue;
+                const sk = readSkillFile(join(dir, file), source);
+                if (sk)
+                    skills.set(sk.name, sk);
+            }
+        }
+        catch {
+            /* unreadable dir — ignore */
+        }
+    }
+    return [...skills.values()].sort((a, b) => {
+        if (a.source !== b.source)
+            return a.source === 'project' ? -1 : 1;
+        return a.name.localeCompare(b.name);
+    });
+}

package/dist/agent/team.js

@@ -1,4 +1,5 @@
 import { modelSupportsTools } from '../api.js';
+import { clearTimCheckpoint, saveTimCheckpoint } from '../config.js';
 import { bold, dim, green, yellow } from '../ui.js';
 import { newSession, runTurn } from './run.js';
 /**
@@ -33,85 +34,164 @@ function tryParsePlan(output) {
 // ---------------------------------------------------------------------------
 // Built-in team: planner-executor
 // ---------------------------------------------------------------------------
-const PLANNER_BRIEF = `Peranmu: PERENCANA. Telusuri kode seperlunya lalu buat rencana langkah kecil & terstruktur.
+const PLANNER_BRIEF = `Peranmu: PERENCANA. Baca SELURUH spesifikasi terlebih dahulu.
 
-WAJIB: panggil tool "selesai" dengan parameter ringkasan berisi JSON dalam format TEPAT ini (tidak ada teks lain sebelum/sesudah JSON):
+LANGKAH WAJIB SEBELUM MERENCANAKAN:
+1. Cari dan baca file spesifikasi/blueprint: blueprint.md, SPEC.md, README.md, atau file .md di root
+2. Pelajari struktur proyek yang sudah ada (daftar_file)
+3. Baru buat rencana langkah yang KOMPREHENSIF mencakup SEMUA fitur yang diminta
+
+WAJIB: panggil tool "selesai" dengan parameter ringkasan berisi JSON dalam format TEPAT ini:
 {"ringkasan":"<ringkasan singkat>","langkah":[{"tugas":"<deskripsi spesifik & actionable>","file":["path/file1.ts"],"catatan":"<konteks tambahan, opsional>"},...]}
 
 Aturan rencana:
-- Masing-masing langkah: 1–3 file, satu perubahan jelas, bisa selesai dalam ~15 tool calls.
-- Maksimal 10 langkah — pecah yang kompleks, gabung yang trivial.
-- Sebutkan path file LENGKAP dan AKURAT (gunakan daftar_file untuk memastikan).
-- JANGAN menulis kode — hanya rencanakan.`;
+- Masing-masing langkah: 1–3 file, satu perubahan jelas
+- Maksimal 15 langkah (untuk aplikasi besar buat lebih banyak langkah kecil)
+- Sebutkan path file LENGKAP dan AKURAT (gunakan daftar_file untuk memastikan)
+- JANGAN menulis kode — hanya rencanakan
+- Pastikan rencana LENGKAP — tidak ada fitur yang terlewat dari spesifikasi`;
 const REVIEWER_BRIEF = 'Peranmu: PENINJAU. Baca file yang relevan dan tinjau hasil implementasi: sebutkan masalah/risiko & saran perbaikan singkat.';
-export async function runTeam(task, opts) {
+/** Append role brief to the existing system message (index 0) instead of pushing a second
+ * system message. Many providers reject or ignore a second {role:'system'} entry before the
+ * first user turn, causing the agent to ignore its role instructions entirely. */
+function appendBrief(session, brief) {
+    const sys = session.messages[0];
+    if (sys?.role === 'system') {
+        sys.content += `\n\n${brief}`;
+    }
+}
+export async function runTeam(task, opts, resume) {
     console.log(bold('👥 Tim agen — mode perencana-eksekutor'));
-    // ① Planner
-    console.log(`\n${bold('① Perencana')} ${dim(`(${opts.models.perencana})`)}`);
-    const plannerSession = newSession(opts.models.perencana, 'rencana', opts.otomatis);
-    plannerSession.messages.push({ role: 'system', content: PLANNER_BRIEF });
-    const planOutput = await runTurn(plannerSession, task);
-    const plan = tryParsePlan(planOutput);
-    if (!plan) {
-        console.log(yellow('⚠ Perencana tidak menghasilkan rencana terstruktur — jalankan sebagai sesi pengkode tunggal.'));
-        const s = newSession(opts.models.pengkode, 'buat', opts.otomatis);
-        s.messages.push({
-            role: 'system',
-            content: 'Peranmu: PENGKODE. Implementasikan tugas mengikuti rencana. Buat perubahan kecil & jelas, lalu panggil selesai.',
-        });
-        await runTurn(s, `Tugas: ${task}\n\nRencana:\n${planOutput || '(tidak ada rencana eksplisit)'}`);
-        console.log(`\n${bold('③ Peninjau')} ${dim(`(${opts.models.peninjau})`)}`);
-        const rev = newSession(opts.models.peninjau, 'rencana', opts.otomatis);
-        rev.messages.push({ role: 'system', content: REVIEWER_BRIEF });
-        await runTurn(rev, `Tinjau hasil implementasi untuk tugas: ${task}`);
-        console.log(green('\n✓ Tim selesai.'));
-        return;
+    let plan = null;
+    // If resuming with a saved plan, skip the planner phase entirely
+    if (resume?.plan) {
+        plan = resume.plan;
+        console.log(yellow(`↩ Melanjutkan dari rencana tersimpan (${plan.langkah.length} langkah)`));
+        console.log(bold(`\n📋 ${plan.ringkasan}`));
+        for (const [i, step] of plan.langkah.entries()) {
+            const done = i < (resume.startFromStep ?? 0);
+            const marker = done ? dim('✓') : dim(`${i + 1}.`);
+            const label = done ? dim(step.tugas) : step.tugas;
+            console.log(`  ${marker} ${label}`);
+            if (!done) {
+                console.log(dim(`     📄 ${step.file.join(', ')}`));
+                if (step.catatan)
+                    console.log(dim(`     💬 ${step.catatan}`));
+            }
+        }
+        console.log('');
     }
-    // Show plan
-    console.log(bold(`\n📋 ${plan.ringkasan}`));
-    for (const [i, step] of plan.langkah.entries()) {
-        console.log(`  ${dim(`${i + 1}.`)} ${step.tugas}`);
-        console.log(dim(`     📄 ${step.file.join(', ')}`));
-        if (step.catatan)
-            console.log(dim(`     💬 ${step.catatan}`));
+    else {
+        // ① Planner
+        console.log(`\n${bold('① Perencana')} ${dim(`(${opts.models.perencana})`)}`);
+        const plannerSession = newSession(opts.models.perencana, 'rencana', opts.otomatis);
+        appendBrief(plannerSession, PLANNER_BRIEF);
+        const planOutput = await runTurn(plannerSession, task);
+        plan = tryParsePlan(planOutput);
+        // Retry once if the planner didn't output valid JSON — it may have just forgotten the format.
+        if (!plan && planOutput.trim()) {
+            console.log(yellow('⚠ Rencana tidak valid — mencoba ulang sekali...'));
+            const retryOutput = await runTurn(plannerSession, 'Output sebelumnya tidak valid. Keluarkan HANYA JSON ini tanpa teks lain:\n{"ringkasan":"...","langkah":[{"tugas":"...","file":["path/file.ts"]}]}');
+            plan = tryParsePlan(retryOutput);
+        }
+        if (!plan) {
+            console.log(yellow('⚠ Perencana tidak menghasilkan rencana terstruktur — jalankan sebagai sesi pengkode tunggal.'));
+            const s = newSession(opts.models.pengkode, 'buat', opts.otomatis);
+            appendBrief(s, 'Peranmu: PENGKODE. Implementasikan tugas mengikuti rencana. Buat perubahan kecil & jelas, lalu panggil selesai.');
+            await runTurn(s, `Tugas: ${task}\n\nRencana:\n${planOutput || '(tidak ada rencana eksplisit)'}`);
+            clearTimCheckpoint();
+            console.log(`\n${bold('③ Peninjau')} ${dim(`(${opts.models.peninjau})`)}`);
+            const rev = newSession(opts.models.peninjau, 'rencana', opts.otomatis);
+            appendBrief(rev, REVIEWER_BRIEF);
+            await runTurn(rev, `Tinjau hasil implementasi untuk tugas: ${task}`);
+            console.log(green('\n✓ Tim selesai.'));
+            return;
+        }
+        // Show plan
+        console.log(bold(`\n📋 ${plan.ringkasan}`));
+        for (const [i, step] of plan.langkah.entries()) {
+            console.log(`  ${dim(`${i + 1}.`)} ${step.tugas}`);
+            console.log(dim(`     📄 ${step.file.join(', ')}`));
+            if (step.catatan)
+                console.log(dim(`     💬 ${step.catatan}`));
+        }
+        console.log('');
+        // Save checkpoint as soon as the plan is established — if execution is interrupted,
+        // `kiosapi lanjut` can resume from step 0 with the existing plan.
+        saveTimCheckpoint({
+            task,
+            plan,
+            completedStepCount: 0,
+            stepResults: [],
+            models: opts.models,
+            otomatis: opts.otomatis,
+        });
     }
-    console.log('');
     // ② Execute each step in a fresh focused session
+    const startFromStep = resume?.startFromStep ?? 0;
+    const completedSteps = resume?.stepResults ? [...resume.stepResults] : [];
+    if (startFromStep > 0) {
+        console.log(yellow(`↩ Melanjutkan dari langkah ${startFromStep + 1}/${plan.langkah.length}`));
+    }
     for (const [i, step] of plan.langkah.entries()) {
+        if (i < startFromStep)
+            continue; // skip already-completed steps
         const label = `${i + 1}/${plan.langkah.length}`;
         console.log(bold(`\n② Pengkode — Langkah ${label}`) + dim(`: ${step.tugas}`));
         console.log(dim(`   📄 ${step.file.join(', ')}`));
         const s = newSession(opts.models.pengkode, 'buat', opts.otomatis);
-        s.messages.push({
-            role: 'system',
-            content: [
-                `Peranmu: PENGKODE — langkah ${label} dari rencana keseluruhan.`,
-                `TUGAS: ${step.tugas}`,
-                `File relevan: ${step.file.join(', ')}`,
-                step.catatan ? `Catatan: ${step.catatan}` : '',
-                'Fokus HANYA pada tugas ini. Baca file relevan, buat perubahan, panggil selesai.',
-                'Jangan baca file lain kecuali diperlukan langsung untuk memahami konteks.',
-            ]
-                .filter(Boolean)
-                .join('\n'),
-        });
+        s.maxSteps = 30; // executor steps are focused (1-3 files) — keep tight
+        appendBrief(s, [
+            `Peranmu: PENGKODE — langkah ${label} dari ${plan.langkah.length}.`,
+            `TUJUAN KESELURUHAN: ${task.slice(0, 400)}`,
+            `RINGKASAN RENCANA: ${plan.ringkasan}`,
+            '',
+            `TUGAS LANGKAH INI: ${step.tugas}`,
+            `File relevan: ${step.file.join(', ')}`,
+            step.catatan ? `Catatan: ${step.catatan}` : '',
+            '',
+            'Fokus HANYA pada tugas ini. Baca file relevan, buat perubahan, panggil selesai.',
+            'Jangan baca file lain kecuali diperlukan langsung untuk memahami konteks.',
+        ]
+            .filter(Boolean)
+            .join('\n'));
+        const previousContext = completedSteps.length > 0
+            ? `\n\n[Progress sebelumnya (${completedSteps.length} langkah selesai):\n${completedSteps.slice(-5).join('\n')}]`
+            : '';
         const stepPrompt = [
             step.tugas,
             `\nFile: ${step.file.join(', ')}`,
             step.catatan ? `\nCatatan: ${step.catatan}` : '',
+            previousContext,
         ]
             .filter(Boolean)
             .join('');
-        await runTurn(s, stepPrompt);
+        const stepStart = Date.now();
+        const stepResult = await runTurn(s, stepPrompt);
+        const elapsed = Math.round((Date.now() - stepStart) / 1000);
+        const didComplete = s._lastCompleted === true;
+        const outcome = stepResult?.trim().slice(0, 500) || '(tidak ada output eksplisit)';
+        completedSteps.push(`Langkah ${i + 1} "${step.tugas}" [${didComplete ? '✓' : '⚠'}]: ${outcome}`);
+        const statusLine = didComplete
+            ? green(`✓ Langkah ${label} selesai`)
+            : yellow(`⚠ Langkah ${label} mungkin tidak tuntas`);
+        console.log(`${statusLine} ${dim(`(${elapsed}s)`)}`);
+        // Persist progress after every step — a crash here loses at most one step
+        saveTimCheckpoint({
+            task,
+            plan,
+            completedStepCount: i + 1,
+            stepResults: completedSteps,
+            models: opts.models,
+            otomatis: opts.otomatis,
+        });
     }
-    // ③ Reviewer — pass the plan so it knows which files were touched
+    // ③ Reviewer — receives the plan + step outcomes so it knows what actually happened
     console.log(`\n${bold('③ Peninjau')} ${dim(`(${opts.models.peninjau})`)}`);
-    const stepSummary = plan.langkah
-        .map((s, i) => `  ${i + 1}. ${s.tugas} [${s.file.join(', ')}]`)
-        .join('\n');
     const rev = newSession(opts.models.peninjau, 'rencana', opts.otomatis);
-    rev.messages.push({ role: 'system', content: REVIEWER_BRIEF });
-    await runTurn(rev, `Tinjau hasil implementasi untuk tugas: ${task}\n\nLangkah yang sudah dikerjakan:\n${stepSummary}`);
+    appendBrief(rev, REVIEWER_BRIEF);
+    await runTurn(rev, `Tinjau hasil implementasi untuk tugas: ${task}\n\nHasil per langkah:\n${completedSteps.join('\n')}`);
+    clearTimCheckpoint();
     console.log(green('\n✓ Tim selesai.'));
 }
 // ---------------------------------------------------------------------------
@@ -144,7 +224,7 @@ export async function runCustomTeam(task, opts) {
         console.log(`\n${bold(`${String(i + 1).padStart(2)}. ${roleName}`)} ${dim(`(${model}, mode: ${mode})`)}`);
         const s = newSession(model, mode, otomatis);
         if (roleCfg.brief)
-            s.messages.push({ role: 'system', content: roleCfg.brief });
+            appendBrief(s, roleCfg.brief);
         const result = await runTurn(s, context);
         const trimmed = (result ?? '').trim();
         const capped = trimmed.length > MAX_ROLE_OUTPUT

package/dist/commands.js

@@ -1,13 +1,15 @@
 import { spawnSync } from 'node:child_process';
-import { readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { extname } from 'node:path';
 import { createInterface } from 'node:readline/promises';
 import { parseArgs } from 'node:util';
+import { McpManager } from './agent/mcp.js';
 import { loadCheckpoint, runAgent } from './agent/run.js';
+import { listSkills, loadSkill } from './agent/skills.js';
 import { runCustomTeam, runTeam } from './agent/team.js';
 import { expandAtMentions } from './agent/tools.js';
 import { createTopup, fetchBytesAuthed, fetchLatestVersion, fetchModels, fetchPemakaian, fetchSaldo, generateImage, modelSupportsTools, pollJob, resolveMediaModel, resolveModel, streamChat, streamVision, submitVideo, } from './api.js';
-import { clearKey, fileConfig, initProjectConfig, listTeamConfigs, loadConfig, loadProjectConfig, loadTeamConfig, saveConfig, saveTeamConfig, } from './config.js';
+import { SKILLS_GLOBAL_DIR, clearKey, fileConfig, initProjectConfig, listTeamConfigs, loadConfig, loadMcpServers, loadProjectConfig, loadRawMcpConfig, loadTeamConfig, projectSkillsDir, saveConfig, saveMcpConfig, saveTeamConfig, } from './config.js';
 import { VERSION } from './help.js';
 import { bold, cyan, dim, green, idn, prompt, promptHidden, readStdin, red, rupiah, sleep, thinking, yellow, } from './ui.js';
 const IMAGE_MIME = {
@@ -483,6 +485,219 @@ async function timBuatWizard(nama) {
     console.log(dim(`  Edit  : ~/.kiosapi/tim/${nama}.json`));
     console.log(dim(`  Jalankan: kiosapi tim --pakai ${nama} "tugas"`));
 }
+// ---------------------------------------------------------------------------
+// mcp — manage MCP server connections
+// ---------------------------------------------------------------------------
+const MCP_TEMPLATE = {
+    mcpServers: {
+        filesystem: {
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-filesystem', '.'],
+        },
+        github: {
+            command: 'npx',
+            args: ['-y', '@modelcontextprotocol/server-github'],
+            env: { GITHUB_TOKEN: 'ghp_YOUR_TOKEN_HERE' },
+        },
+    },
+};
+/**
+ * mcp — list, test, or scaffold MCP server configuration.
+ *   kiosapi mcp              List configured servers
+ *   kiosapi mcp sambung      Connect to all servers and show available tools
+ *   kiosapi mcp init         Scaffold ~/.kiosapi/mcp.json with examples
+ */
+export async function cmdMcp(args) {
+    const sub = (args[0] ?? '').toLowerCase();
+    // kiosapi mcp init — scaffold config file
+    if (sub === 'init') {
+        const { DIR } = await import('./config.js');
+        const path = `${DIR}/mcp.json`;
+        const { existsSync } = await import('node:fs');
+        if (existsSync(path)) {
+            console.log(yellow('~/.kiosapi/mcp.json sudah ada. Edit langsung:'));
+            console.log(path);
+            console.log(JSON.stringify(loadRawMcpConfig(), null, 2));
+            return;
+        }
+        saveMcpConfig(MCP_TEMPLATE.mcpServers);
+        console.log(green('✓ ~/.kiosapi/mcp.json dibuat'));
+        console.log(dim('  Edit untuk sesuaikan server dan path, lalu jalankan: kiosapi mcp sambung'));
+        console.log(JSON.stringify(MCP_TEMPLATE, null, 2));
+        return;
+    }
+    const servers = loadMcpServers();
+    const serverCount = Object.keys(servers).length;
+    // kiosapi mcp — list configured servers (no connection)
+    if (!sub || sub === 'daftar' || sub === 'list') {
+        if (serverCount === 0) {
+            console.log(dim('Belum ada MCP server dikonfigurasi.'));
+            console.log(dim('  Scaffold: kiosapi mcp init'));
+            console.log(dim('  Config  : ~/.kiosapi/mcp.json  atau  kiosapi.json → mcpServers'));
+            return;
+        }
+        console.log(bold(`MCP Servers (${serverCount}):`));
+        for (const [name, cfg] of Object.entries(servers)) {
+            const cmd = [cfg.command, ...(cfg.args ?? [])].join(' ');
+            console.log(`  ${cyan(name)}  ${dim(cmd)}`);
+        }
+        console.log(dim('\nTest koneksi: kiosapi mcp sambung'));
+        return;
+    }
+    // kiosapi mcp sambung — connect and list tools
+    if (sub === 'sambung' || sub === 'connect' || sub === 'test') {
+        if (serverCount === 0) {
+            console.log(dim('Belum ada MCP server dikonfigurasi. Jalankan: kiosapi mcp init'));
+            return;
+        }
+        console.log(dim(`Menghubungkan ke ${serverCount} server MCP…`));
+        const mgr = new McpManager();
+        try {
+            await mgr.connect(servers, (warn) => console.log(yellow(warn)));
+            if (mgr.toolCount === 0) {
+                console.log(yellow('Tidak ada tools yang tersedia dari server yang terhubung.'));
+                return;
+            }
+            console.log(green(`\n✓ ${mgr.serverCount} server · ${mgr.toolCount} tools\n`));
+            for (const { server, tools } of mgr.summary()) {
+                console.log(bold(`  ${server}`));
+                for (const t of tools) {
+                    const desc = (t.spec.function.description ?? '').replace(`[MCP:${server}] `, '');
+                    console.log(`    ${cyan(t.toolName)}  ${dim(desc.slice(0, 70))}`);
+                }
+            }
+            console.log(dim('\nTools ini tersedia otomatis di semua sesi agen.'));
+        }
+        finally {
+            mgr.disconnect();
+        }
+        return;
+    }
+    console.log(red(`Sub-perintah tidak dikenal: mcp ${sub}`));
+    console.log(dim('  kiosapi mcp          — lihat server dikonfigurasi'));
+    console.log(dim('  kiosapi mcp sambung  — test koneksi + lihat tools'));
+    console.log(dim('  kiosapi mcp init     — scaffold ~/.kiosapi/mcp.json'));
+}
+// ---------------------------------------------------------------------------
+// skill — reusable saved agent workflows
+// ---------------------------------------------------------------------------
+const SKILL_TEMPLATE = `---
+mode: buat
+# otomatis: false
+# model: deepseek/deepseek-v4-flash
+description: Deskripsi singkat skill ini
+---
+Tulis prompt skillmu di sini.
+
+Tips — gunakan @-mention untuk menyertakan konteks:
+  @git:diff           git diff saat ini
+  @git:status         status working tree
+  @src/**/*.ts        semua file .ts di src/
+  @path/to/file.ts    file spesifik
+
+Contoh:
+  Review @git:diff, identifikasi masalah potensial, dan buat laporan ringkas.
+`;
+/** Try to open a file in the user's preferred editor; falls back to printing the path. */
+function openInEditor(filePath) {
+    const editor = process.env.EDITOR || process.env.VISUAL;
+    if (!editor) {
+        console.log(dim(`  Buka di editor: ${filePath}`));
+        return;
+    }
+    const res = spawnSync(editor, [filePath], { stdio: 'inherit' });
+    if (res.error)
+        console.log(dim(`  Edit manual: ${filePath}`));
+}
+/**
+ * skill — create, list, or run saved skill files.
+ *   kiosapi skill buat [nama]       Buat skill baru (project scope)
+ *   kiosapi skill buat --global [nama]  Buat skill di ~/.kiosapi/skills/
+ *   kiosapi skill <nama> [konteks]  Jalankan skill
+ *   kiosapi skills                  Sama dengan kiosapi skill --daftar
+ */
+export async function cmdSkill(args) {
+    const sub = args[0]?.toLowerCase();
+    // kiosapi skill buat [--global] [nama]
+    if (sub === 'buat' || sub === 'create' || sub === 'new') {
+        const rest = args.slice(1);
+        const isGlobal = rest[0] === '--global' || rest[0] === '-g';
+        const nameArg = isGlobal ? rest[1] : rest[0];
+        const name = nameArg?.trim() || (await prompt('Nama skill (huruf kecil, tanda hubung): ')).trim();
+        if (!name)
+            throw new Error('Nama skill tidak boleh kosong.');
+        if (!/^[\w-]+$/.test(name))
+            throw new Error('Nama hanya boleh huruf, angka, dan tanda hubung.');
+        const dir = isGlobal ? SKILLS_GLOBAL_DIR : projectSkillsDir();
+        mkdirSync(dir, { recursive: true });
+        const filePath = `${dir}/${name}.md`;
+        writeFileSync(filePath, SKILL_TEMPLATE);
+        const scope = isGlobal ? 'global (~/.kiosapi/skills/)' : 'project (.kiosapi/skills/)';
+        console.log(green(`\n✓ Skill "${name}" dibuat (${scope})`));
+        console.log(dim(`  File: ${filePath}`));
+        console.log(dim(`  Jalankan: kiosapi skill ${name}`));
+        console.log(dim('  Edit prompt & frontmatter lalu simpan.\n'));
+        openInEditor(filePath);
+        return;
+    }
+    // kiosapi skill --daftar | kiosapi skills
+    if (!sub || sub === '--daftar' || sub === '--list' || sub === 'daftar' || sub === 'list') {
+        return cmdSkills();
+    }
+    // kiosapi skill <nama> [-m model] [--otomatis] [extra context…]
+    const skillName = sub;
+    const { values: flagValues, positionals: extraPositionals } = parseArgs({
+        args: args.slice(1),
+        options: { model: { type: 'string', short: 'm' }, otomatis: { type: 'boolean' } },
+        allowPositionals: true,
+        strict: false,
+    });
+    const extraArgs = extraPositionals.join(' ').trim();
+    const skill = loadSkill(skillName);
+    if (!skill) {
+        console.error(red(`Skill "${skillName}" tidak ditemukan.`));
+        console.log(dim('  Buat baru: kiosapi skill buat <nama>'));
+        console.log(dim('  Lihat daftar: kiosapi skills'));
+        process.exitCode = 1;
+        return;
+    }
+    const cfg = loadConfig();
+    const model = flagValues.model ?? skill.model ?? cfg.defaultModel;
+    const resolvedModel = await resolveModel(model);
+    const otomatis = flagValues.otomatis ?? skill.otomatis;
+    const scopeLabel = skill.source === 'project' ? dim(' [project]') : dim(' [global]');
+    console.log(`${bold(`▶ ${skill.name}`)}${scopeLabel}${skill.description ? ` — ${dim(skill.description)}` : ''}`);
+    const prompt_ = extraArgs ? `${skill.prompt}\n\n${extraArgs}` : skill.prompt;
+    const expanded = await expandAtMentions(prompt_);
+    await runAgent(expanded, skill.mode, { model: resolvedModel, otomatis });
+}
+/** skills — list all available skills. */
+export async function cmdSkills() {
+    const all = listSkills();
+    if (all.length === 0) {
+        console.log(dim('Belum ada skill.'));
+        console.log(dim('  Buat baru: kiosapi skill buat <nama>'));
+        return;
+    }
+    const projectSkills = all.filter((s) => s.source === 'project');
+    const globalSkills = all.filter((s) => s.source === 'global');
+    if (projectSkills.length > 0) {
+        console.log(bold('\nSkill project (.kiosapi/skills/):'));
+        for (const sk of projectSkills) {
+            const desc = sk.description ? dim(` — ${sk.description}`) : '';
+            console.log(`  ${cyan(sk.name)}${desc}  ${dim(`[${sk.mode}]`)}`);
+        }
+    }
+    if (globalSkills.length > 0) {
+        console.log(bold('\nSkill global (~/.kiosapi/skills/):'));
+        for (const sk of globalSkills) {
+            const desc = sk.description ? dim(` — ${sk.description}`) : '';
+            console.log(`  ${cyan(sk.name)}${desc}  ${dim(`[${sk.mode}]`)}`);
+        }
+    }
+    console.log(dim('\nJalankan: kiosapi skill <nama>'));
+    console.log(dim('Buat baru: kiosapi skill buat <nama>'));
+}
 const ALL_COMMANDS = [
     'masuk',
     'keluar',
@@ -505,6 +720,9 @@ const ALL_COMMANDS = [
     'lihat',
     'lanjut',
     'init',
+    'skill',
+    'skills',
+    'mcp',
     'completion',
     // English aliases
     'login',
@@ -637,6 +855,8 @@ export async function cmdTim(args) {
     const task = positionals.join(' ').trim();
     if (!task)
         throw new Error('Beri tugas. Contoh: kiosapi tim "bikin endpoint /health + tes"');
+    // Expand @file mentions so users can pass: kiosapi tim "@blueprint.md"
+    const expandedTask = await expandAtMentions(task);
     const base = await resolveModel(values.model);
     const models = {
         perencana: values.perencana ?? base,
@@ -645,7 +865,7 @@ export async function cmdTim(args) {
     };
     for (const m of new Set(Object.values(models)))
         await warnIfNoTools(m);
-    await runTeam(task, { models, otomatis: Boolean(values.otomatis) });
+    await runTeam(expandedTask, { models, otomatis: Boolean(values.otomatis) });
 }
 /** saldo — show own balance, bonus tokens, and month-to-date spend. */
 export async function cmdSaldo() {

package/dist/config.js

@@ -1,4 +1,4 @@
-import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync, } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 const DEFAULT_BASE_URL = 'https://api.kiosapi.id';
@@ -6,6 +6,13 @@ export const DIR = join(homedir(), '.kiosapi');
 export const CONFIG_PATH = join(DIR, 'config.json');
 export const CHECKPOINT_PATH = join(DIR, 'checkpoint.json');
 export const TIM_DIR = join(DIR, 'tim');
+export const TIM_CHECKPOINT_PATH = join(DIR, 'tim-checkpoint.json');
+export const SKILLS_GLOBAL_DIR = join(DIR, 'skills');
+const MCP_CONFIG_PATH = join(DIR, 'mcp.json');
+/** Returns the project-level skills directory (.kiosapi/skills/ under cwd). */
+export function projectSkillsDir() {
+    return join(process.cwd(), '.kiosapi', 'skills');
+}
 /** Read only the on-disk config (ignores env overrides) — used before writing. */
 function readFile() {
     if (!existsSync(CONFIG_PATH))
@@ -96,6 +103,71 @@ export function initProjectConfig(config) {
     writeFileSync(p, `${JSON.stringify(config, null, 2)}\n`);
     return p;
 }
+export function saveTimCheckpoint(data) {
+    mkdirSync(DIR, { recursive: true });
+    const full = {
+        type: 'tim',
+        ...data,
+        savedAt: new Date().toISOString(),
+        cwd: process.cwd(),
+    };
+    writeFileSync(TIM_CHECKPOINT_PATH, `${JSON.stringify(full, null, 2)}\n`);
+}
+export function loadTimCheckpoint() {
+    if (!existsSync(TIM_CHECKPOINT_PATH))
+        return null;
+    try {
+        const data = JSON.parse(readFileSync(TIM_CHECKPOINT_PATH, 'utf8'));
+        if (data.type !== 'tim')
+            return null;
+        return data;
+    }
+    catch {
+        return null;
+    }
+}
+export function clearTimCheckpoint() {
+    try {
+        unlinkSync(TIM_CHECKPOINT_PATH);
+    }
+    catch {
+        // already gone
+    }
+}
+/**
+ * Load all MCP server configs: global (~/.kiosapi/mcp.json) merged with project (kiosapi.json).
+ * Project entries override global ones on name collision.
+ */
+export function loadMcpServers() {
+    let global = {};
+    if (existsSync(MCP_CONFIG_PATH)) {
+        try {
+            const data = JSON.parse(readFileSync(MCP_CONFIG_PATH, 'utf8'));
+            global = data.mcpServers ?? {};
+        }
+        catch {
+            /* corrupt file — ignore */
+        }
+    }
+    const project = loadProjectConfig()?.mcpServers ?? {};
+    return { ...global, ...project };
+}
+/** Write the global MCP config file. */
+export function saveMcpConfig(servers) {
+    mkdirSync(DIR, { recursive: true });
+    writeFileSync(MCP_CONFIG_PATH, `${JSON.stringify({ mcpServers: servers }, null, 2)}\n`);
+}
+/** Read the raw global MCP config (for display / editing). */
+export function loadRawMcpConfig() {
+    if (!existsSync(MCP_CONFIG_PATH))
+        return { mcpServers: {} };
+    try {
+        return JSON.parse(readFileSync(MCP_CONFIG_PATH, 'utf8'));
+    }
+    catch {
+        return { mcpServers: {} };
+    }
+}
 /** List all saved team names. */
 export function listTeamConfigs() {
     if (!existsSync(TIM_DIR))

package/dist/help.js

@@ -47,6 +47,20 @@ ${bold('Agen (butuh model 🔧):')}
   init                    Buat kiosapi.json (config per-project: model, mode, otomatis)
   ${dim('Opsi: -m <model>, --otomatis (lewati konfirmasi). Mendukung pipe stdin.')}
 
+${bold('Skills (workflow tersimpan):')}
+  skill buat <nama>       Buat skill baru di project (.kiosapi/skills/)
+  skill buat --global <n> Buat skill global (~/.kiosapi/skills/)
+  skill <nama> [konteks]  Jalankan skill; konteks opsional ditambahkan ke prompt
+  skills                  Lihat semua skill tersimpan (project + global)
+  ${dim('Dalam sesi: /skills · /skill <nama> [konteks]')}
+
+${bold('MCP (Model Context Protocol):')}
+  mcp                     Lihat server MCP dikonfigurasi
+  mcp sambung             Test koneksi + lihat tools tersedia
+  mcp init                Buat ~/.kiosapi/mcp.json dengan contoh konfigurasi
+  ${dim('Config: ~/.kiosapi/mcp.json (global) atau kiosapi.json → mcpServers (per-project)')}
+  ${dim('Tools MCP otomatis tersedia di semua sesi agen dan tim mode.')}
+
 ${bold('Tim multi-agen:')}
   tim "…"                 Jalankan tim bawaan (perencana → pengkode → peninjau)
   tim --pakai <nama> "…"  Jalankan tim kustom tersimpan
@@ -72,6 +86,11 @@ ${bold('Contoh:')}
   kiosapi lanjut
   kiosapi tim --buat fullstack-team
   kiosapi tim --pakai fullstack-team "bikin halaman login"
+  kiosapi skill buat fix-tests
+  kiosapi skill fix-tests
+  kiosapi skills
+  kiosapi mcp init
+  kiosapi mcp sambung
   kiosapi completion bash >> ~/.bashrc
 
 ${dim('Sesi interaktif: /undo batalkan giliran terakhir · /ringkas padatkan riwayat · /model ganti model.')}

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { cmdBuat, cmdCompletion, cmdEdit, cmdGambar, cmdInit, cmdIsi, cmdKeluar, cmdLihat, cmdMasuk, cmdModel, cmdNgobrol, cmdPakai, cmdPerbarui, cmdPeriksa, cmdRencana, cmdSaldo, cmdSambung, cmdSetel, cmdTanya, cmdTim, cmdVideo, maybeNotifyUpdate, } from './commands.js';
+import { cmdBuat, cmdCompletion, cmdEdit, cmdGambar, cmdInit, cmdIsi, cmdKeluar, cmdLihat, cmdMasuk, cmdMcp, cmdModel, cmdNgobrol, cmdPakai, cmdPerbarui, cmdPeriksa, cmdRencana, cmdSaldo, cmdSambung, cmdSetel, cmdSkill, cmdSkills, cmdTanya, cmdTim, cmdVideo, maybeNotifyUpdate, } from './commands.js';
 import { printHelp, printVersion } from './help.js';
 import { resumeFromCheckpoint, startSession } from './session.js';
 import { red } from './ui.js';
@@ -44,6 +44,9 @@ const COMMANDS = {
     lanjut: resumeFromCheckpoint,
     resume: resumeFromCheckpoint,
     init: cmdInit,
+    skill: cmdSkill,
+    skills: cmdSkills,
+    mcp: cmdMcp,
     completion: cmdCompletion,
 };
 async function main() {

package/dist/session.js

@@ -1,10 +1,12 @@
 import { spawnSync } from 'node:child_process';
+import { McpManager } from './agent/mcp.js';
 import { clearCheckpoint, loadCheckpoint, newSession, resetSession, runTurn, undoLastTurn, } from './agent/run.js';
+import { listSkills, loadSkill } from './agent/skills.js';
 import { runCustomTeam, runTeam } from './agent/team.js';
 import { expandAtMentions } from './agent/tools.js';
 import { resolveModel, streamChat } from './api.js';
-import { cmdGambar, cmdIsi, cmdLihat, cmdMasuk, cmdPakai, cmdPerbarui, cmdSaldo, cmdVideo, maybeNotifyUpdate, pickModel, warnIfNoTools, } from './commands.js';
-import { listTeamConfigs, loadConfig, loadProjectConfig, loadTeamConfig, saveTeamConfig, } from './config.js';
+import { cmdGambar, cmdIsi, cmdLihat, cmdMasuk, cmdPakai, cmdPerbarui, cmdSaldo, cmdSkill, cmdVideo, maybeNotifyUpdate, pickModel, warnIfNoTools, } from './commands.js';
+import { clearTimCheckpoint, listTeamConfigs, loadConfig, loadMcpServers, loadProjectConfig, loadTeamConfig, loadTimCheckpoint, saveTeamConfig, } from './config.js';
 import { bold, cyan, dim, green, idn, prompt, red, thinking, yellow } from './ui.js';
 const MODES = ['rencana', 'edit', 'buat'];
 /** The prompt indicator shows the active mode, turn count, accumulated tokens, and ⚡ for auto. */
@@ -23,6 +25,8 @@ ${dim('Ketik tugasmu langsung. Perintah meta diawali "/". /bantuan untuk daftar,
 }
 function slashHelp() {
     console.log(`${bold('Perintah sesi:')}
+  /skills                         Lihat semua skill tersimpan
+  /skill <nama> [konteks]         Jalankan skill (project atau global)
   /tim <tugas>                    Multi-agen bawaan (perencana→pengkode→peninjau)
   /tim --pakai <nama> <tugas>     Jalankan tim kustom tersimpan
   /peran [peran] [model]          Atur model per peran tim (atau lihat/reset)
@@ -65,6 +69,64 @@ async function runSlash(line, s) {
             case '?':
                 slashHelp();
                 return false;
+            case 'skills':
+            case 'skill-daftar': {
+                const all = listSkills();
+                if (all.length === 0) {
+                    console.log(dim('Belum ada skill. Buat dengan: kiosapi skill buat <nama>'));
+                }
+                else {
+                    for (const sk of all) {
+                        const scopeTag = sk.source === 'project' ? '[project]' : '[global]';
+                        const desc = sk.description ? ` — ${sk.description}` : '';
+                        console.log(`  ${cyan(sk.name)} ${dim(scopeTag)}${dim(desc)}  ${dim(`[${sk.mode}]`)}`);
+                    }
+                }
+                return false;
+            }
+            case 'skill': {
+                const skillName = rest[0];
+                if (!skillName) {
+                    // No name → show list
+                    const all = listSkills();
+                    if (all.length === 0) {
+                        console.log(dim('Belum ada skill. Buat dengan: kiosapi skill buat <nama>'));
+                    }
+                    else {
+                        for (const sk of all) {
+                            const desc = sk.description ? dim(` — ${sk.description}`) : '';
+                            console.log(`  ${cyan(sk.name)}${desc}  ${dim(`[${sk.mode}]`)}`);
+                        }
+                    }
+                    return false;
+                }
+                const sk = loadSkill(skillName);
+                if (!sk) {
+                    console.log(red(`Skill "${skillName}" tidak ditemukan.`));
+                    console.log(dim('  Buat: kiosapi skill buat <nama>  |  Lihat: /skills'));
+                    return false;
+                }
+                const extra = rest.slice(1).join(' ').trim();
+                const rawPrompt = extra ? `${sk.prompt}\n\n${extra}` : sk.prompt;
+                const expanded = await expandAtMentions(rawPrompt);
+                // Apply skill's model/mode/otomatis to the current session for this turn only
+                const prevModel = s.model;
+                const prevMode = s.mode;
+                const prevOto = s.otomatis;
+                if (sk.model)
+                    s.model = sk.model;
+                s.mode = sk.mode;
+                if (sk.otomatis)
+                    s.otomatis = true;
+                const scopeLabel = sk.source === 'project' ? dim(' [project]') : dim(' [global]');
+                console.log(`${bold(`▶ skill: ${sk.name}`)}${scopeLabel}`);
+                await runTurn(s, expanded);
+                // Restore session settings after skill run
+                s.model = prevModel;
+                s.mode = prevMode;
+                s.otomatis = prevOto;
+                return false;
+            }
             case 'mode': {
                 const m = rest[0]?.toLowerCase();
                 if (!m) {
@@ -483,7 +545,22 @@ export async function startSession() {
     }
     banner(s);
     await warnIfNoTools(model);
-    await runSessionLoop(s);
+    const mcpServers = loadMcpServers();
+    let mcpManager;
+    if (Object.keys(mcpServers).length > 0) {
+        mcpManager = new McpManager();
+        await mcpManager.connect(mcpServers, (w) => console.log(yellow(w)));
+        if (mcpManager.toolCount > 0) {
+            console.log(dim(`  MCP: ${mcpManager.toolCount} tool dari ${mcpManager.serverCount} server`));
+        }
+        s.mcpManager = mcpManager;
+    }
+    try {
+        await runSessionLoop(s);
+    }
+    finally {
+        mcpManager?.disconnect();
+    }
 }
 /**
  * Resume a checkpointed session interactively: load the saved state, show a preamble, ask for a
@@ -492,6 +569,51 @@ export async function startSession() {
  */
 export async function resumeFromCheckpoint(args) {
     await maybeNotifyUpdate();
+    // Tim checkpoint takes priority — it stores multi-step pipeline progress
+    const timCp = loadTimCheckpoint();
+    if (timCp) {
+        console.log(bold('Sesi tim tersimpan ditemukan'));
+        console.log(`  Tugas    : ${timCp.task.slice(0, 80)}${timCp.task.length > 80 ? '…' : ''}`);
+        console.log(`  Progress : ${timCp.completedStepCount}/${timCp.plan.langkah.length} langkah selesai`);
+        console.log(`  Disimpan : ${new Date(timCp.savedAt).toLocaleString('id-ID')}`);
+        if (timCp.completedStepCount > 0) {
+            console.log(dim('  Langkah selesai:'));
+            for (const [i, step] of timCp.plan.langkah.entries()) {
+                if (i >= timCp.completedStepCount)
+                    break;
+                console.log(dim(`    ✓ ${i + 1}. ${step.tugas}`));
+            }
+        }
+        const remaining = timCp.plan.langkah.length - timCp.completedStepCount;
+        console.log(`\n  Sisa     : ${remaining} langkah belum dikerjakan`);
+        if (timCp.cwd !== process.cwd()) {
+            console.log(yellow(`\n⚠ Sesi ini disimpan di direktori berbeda: ${timCp.cwd}`));
+        }
+        if (!loadConfig().apiKey) {
+            console.log(dim('Belum masuk — masukkan API key dulu.'));
+            await cmdMasuk();
+            if (!loadConfig().apiKey)
+                return;
+        }
+        const ans = (await prompt('Lanjutkan sesi tim ini? (y/t) ')).trim().toLowerCase();
+        if (ans === 'y' || ans === 'ya') {
+            const resume = {
+                startFromStep: timCp.completedStepCount,
+                stepResults: timCp.stepResults,
+                plan: timCp.plan,
+            };
+            await runTeam(timCp.task, { models: timCp.models, otomatis: timCp.otomatis }, resume);
+        }
+        else {
+            console.log(dim('Sesi tim dibatalkan.'));
+            const clearAns = (await prompt('Hapus checkpoint tim ini? (y/t) ')).trim().toLowerCase();
+            if (clearAns === 'y' || clearAns === 'ya') {
+                clearTimCheckpoint();
+                console.log(dim('Checkpoint tim dihapus.'));
+            }
+        }
+        return;
+    }
     const cp = loadCheckpoint();
     if (!cp) {
         throw new Error('Tidak ada sesi tersimpan. Mulai dengan: kiosapi buat "tugas"\n' +

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kiosapi",
-  "version": "0.1.28",
+  "version": "0.1.29",
   "type": "module",
   "description": "CLI Kiosapi.id berbahasa Indonesia — bangun aplikasimu pakai API key Kiosapi (agen + multimodal).",
   "keywords": [