agen-vektor 0.3.13 → 0.3.15

package/dist/config/free-tier.js

@@ -9,65 +9,25 @@
  *
  * Design:
  * - `vectorhead-free` is an OpenCode-style entry in config.providers with an
- *   INLINE placeholder key. The gateway identifies users by the anonymous
- *   device id sent via the X-Vector-Device header, so no real key exists —
+ *   INLINE placeholder key. The gateway holds the real provider key as a
+ *   server-side secret and does NOT require any per-device or per-user
+ *   identity from the client (per-device quota was removed 2026-09-05 —
+ *   X-Vector-Device is no longer sent), so no real key exists client-side —
  *   the inline placeholder simply satisfies "custom providers need a key"
  *   checks without storing anything secret on the user's disk.
- * - The device id lives in ~/.vector/device-id (NOT config.json, so config
- *   stays copyable between machines; a copied device id would merge two
- *   users into one quota bucket). Header templating "{env:VECTOR_DEVICE_ID}"
- *   resolves at request time via providerHeaders().
  * - First run (no config.json): the agent starts on this provider so a new
  *   user can chat immediately — pick BYOK later via /connect. An EXISTING
  *   config is never touched except to (re)define the free provider entry.
  */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FREE_DEFAULT_MODEL = exports.FREE_PROVIDER_ID = exports.CATALOG_TTL_MS = exports.FREE_CATALOG_URL = exports.FREE_GATEWAY_CATALOG_URL = exports.FREE_GATEWAY_URL = void 0;
+exports.FREE_LEGACY_MODELS = exports.FREE_DEFAULT_MODEL = exports.FREE_PROVIDER_ID = exports.CATALOG_TTL_MS = exports.FREE_CATALOG_URL = exports.FREE_GATEWAY_CATALOG_URL = exports.FREE_GATEWAY_URL = void 0;
 exports.resetFreeCatalogCache = resetFreeCatalogCache;
 exports.freeTierEnabled = freeTierEnabled;
-exports.ensureDeviceId = ensureDeviceId;
-exports.exportDeviceIdEnv = exportDeviceIdEnv;
 exports.freeProviderDef = freeProviderDef;
 exports.ensureFreeProvider = ensureFreeProvider;
 exports.isFirstRun = isFirstRun;
 exports.fetchFreeCatalog = fetchFreeCatalog;
 exports.applyFreeCatalog = applyFreeCatalog;
-const fs = __importStar(require("node:fs"));
-const crypto = __importStar(require("node:crypto"));
-const paths_1 = require("../utils/paths");
 /** Public gateway base URL (custom Cloudflare domain — stable, no ports). */
 exports.FREE_GATEWAY_URL = 'https://vector-tui.methatech.eu.org/v1';
 /**
@@ -98,39 +58,17 @@ function freeTierEnabled() {
 }
 /** Provider id used in config.provider / providers map. */
 exports.FREE_PROVIDER_ID = 'vectorhead-free';
-/** Default free model (cheap, gateway allowlist-friendly). */
-exports.FREE_DEFAULT_MODEL = 'deepseek-ai/DeepSeek-V4-Flash';
-/** File holding the anonymous per-device id. */
-function devicePath() {
-    return process.env.VECTOR_DEVICE_FILE || ((0, paths_1.getVectorDir)() + '/device-id');
-}
-/** Device id for the anonymous free tier: create on first use, reuse after. */
-function ensureDeviceId() {
-    try {
-        const p = devicePath();
-        if (fs.existsSync(p)) {
-            const existing = fs.readFileSync(p, 'utf8').trim();
-            if (/^[a-f0-9][a-f0-9-]{7,63}$/.test(existing))
-                return existing;
-        }
-        const fresh = crypto.randomUUID();
-        fs.writeFileSync(p, fresh + '\n', { mode: 0o600 });
-        return fresh;
-    }
-    catch {
-        // Read-only fs etc. — fall back to an ephemeral id for this session.
-        return crypto.randomUUID();
-    }
-}
-/** Export the current device id into the env for {env:} header templates. */
-function exportDeviceIdEnv() {
-    try {
-        process.env.VECTOR_DEVICE_ID = ensureDeviceId();
-    }
-    catch {
-        /* never block startup on this */
-    }
-}
+/**
+ * Default free model (cheap, gateway allowlist-friendly). 2026-09-07: BACK
+ * to `glm-5.3-flash` — the gateway allowlist flipped back from the 7-model
+ * Claude window to the api.b.ai set: live GET /v1/models now serves hy3,
+ * glm-5.3-flash, qwen3.8-max, mimo-v2.5, so `claude-sonnet-4-6` (the
+ * 2026-09-06-malam default) is the id that would 404 on fresh installs.
+ * glm-5.3-flash verified live end-to-end via the relay (chat 200). History
+ * of the same trap: `deepseek-ai/DeepSeek-V4-Flash` (first default), then
+ * claude-sonnet-4-6, now glm-5.3-flash again.
+ */
+exports.FREE_DEFAULT_MODEL = 'glm-5.3-flash';
 /** The providers-map entry for the free tier (idempotent — same shape always). */
 function freeProviderDef() {
     // When a catalog has been fetched in this process, the gateway URL and
@@ -149,29 +87,44 @@ function freeProviderDef() {
         name: 'VectorHead Free',
         options: {
             baseURL: (cat && typeof cat.gateway === 'string' && cat.gateway ? cat.gateway : exports.FREE_GATEWAY_URL),
-            // Placeholder ONLY — the gateway keys users by X-Vector-Device, not
-            // by a secret. Inline (not {env:}) so no env var is ever required.
+            // Placeholder ONLY — the gateway holds the real provider key as a
+            // server-side secret and accepts anonymous requests. Inline (not
+            // {env:}) so no env var is ever required.
             apiKey: 'vectorhead-free-anonymous',
-            headers: { 'X-Vector-Device': '{env:VECTOR_DEVICE_ID}' },
         },
         model: exports.FREE_DEFAULT_MODEL,
         models: Object.keys(models).length > 0 ? models : {
-            [exports.FREE_DEFAULT_MODEL]: { name: 'DeepSeek V4 Flash (free)' },
+            [exports.FREE_DEFAULT_MODEL]: { name: 'GLM 5.3 Flash (free)' },
         },
     };
 }
+/**
+ * Stale first-run defaults — migrated to FREE_DEFAULT_MODEL once on
+ * ensureFreeProvider (only while the free provider is active). glm-5.3-flash
+ * itself was legacy during the 2026-09-06 Claude window; since 2026-09-07 it
+ * is the default again, so the stale set is the original deepseek default
+ * plus that window's claude default (no longer in the gateway allowlist).
+ */
+exports.FREE_LEGACY_MODELS = ['deepseek-ai/DeepSeek-V4-Flash', 'claude-sonnet-4-6'];
 /**
  * Ensure the free provider entry exists in the config's providers map
- * (create or repair — never touches unrelated providers). Returns true when
- * the config object was modified.
+ * (create or repair — never touches unrelated providers). Also migrates an
+ * active free-tier model that still points at the STALE legacy default.
+ * Returns true when the config object was modified.
  */
 function ensureFreeProvider(config) {
     const cur = config.providers?.[exports.FREE_PROVIDER_ID];
     const want = JSON.stringify(freeProviderDef());
-    if (cur && JSON.stringify(cur) === want)
-        return false;
-    config.providers = { ...(config.providers || {}), [exports.FREE_PROVIDER_ID]: freeProviderDef() };
-    return true;
+    let changed = false;
+    if (!cur || JSON.stringify(cur) !== want) {
+        config.providers = { ...(config.providers || {}), [exports.FREE_PROVIDER_ID]: freeProviderDef() };
+        changed = true;
+    }
+    if (config.provider === exports.FREE_PROVIDER_ID && exports.FREE_LEGACY_MODELS.includes(config.model || '')) {
+        config.model = exports.FREE_DEFAULT_MODEL;
+        changed = true;
+    }
+    return changed;
 }
 /**
  * True when this machine has never run VectorHead before (no config.json).

package/dist/providers/anthropic.js

@@ -234,7 +234,7 @@ class AnthropicProvider {
                     else if (evtName === 'content_block_delta') {
                         const delta = json.delta;
                         if (delta?.type === 'text_delta' && typeof delta.text === 'string') {
-                            content += delta.text;
+                            content = (0, provider_1.mergeStreamDelta)(content, delta.text);
                             yield { type: 'delta', delta: delta.text };
                         }
                         else if (delta?.type === 'thinking_delta' && typeof delta.thinking === 'string') {

package/dist/providers/gemini.js

@@ -202,7 +202,7 @@ class GeminiProvider {
                     yield { type: 'delta', reasoning: deltaThought };
                 }
                 if (deltaText) {
-                    content += deltaText;
+                    content = (0, provider_1.mergeStreamDelta)(content, deltaText);
                     yield { type: 'delta', delta: deltaText };
                 }
                 for (const tc of newCalls) {

package/dist/providers/ollama.js

@@ -159,7 +159,7 @@ class OllamaProvider {
                     yield { type: 'delta', reasoning: message.thinking };
                 }
                 if (typeof message.content === 'string' && message.content) {
-                    content += message.content;
+                    content = (0, provider_1.mergeStreamDelta)(content, message.content);
                     yield { type: 'delta', delta: message.content };
                 }
                 const tcs = message.tool_calls || [];

package/dist/providers/openai-compat.js

@@ -338,7 +338,22 @@ class OpenAICompatProvider {
     }
     async *stream(params) {
         const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 180_000);
+        // 180s TOTAL deadline is wrong for a streaming response: a long agentic
+        // turn (big diff, slow reasoning model, cold gateway) can legitimately
+        // run for minutes — as long as bytes keep arriving the stream is ALIVE.
+        // Instead: IDLE timeout — the clock resets on every chunk, so it only
+        // fires when the connection truly stalls (the "stuck mid-task" report).
+        // A hard cap remains (IDLE_MAX_TOTAL_MS) for pathological never-ending
+        // streams.
+        const IDLE_TIMEOUT_MS = 120_000;
+        const IDLE_MAX_TOTAL_MS = 600_000;
+        let idleTimer = null;
+        const armIdle = () => {
+            if (idleTimer)
+                clearTimeout(idleTimer);
+            idleTimer = setTimeout(() => controller.abort(), IDLE_TIMEOUT_MS);
+        };
+        const timer = setTimeout(() => controller.abort(), IDLE_MAX_TOTAL_MS);
         const onOuterAbort = () => controller.abort();
         if (params.signal) {
             if (params.signal.aborted)
@@ -347,6 +362,10 @@ class OpenAICompatProvider {
                 params.signal.addEventListener('abort', onOuterAbort);
         }
         try {
+            // Arm the idle clock immediately: connect + time-to-first-byte must
+            // arrive within IDLE_TIMEOUT_MS too (previously this window had NO
+            // timer at all — a dead upstream sat forever on the spinner).
+            armIdle();
             const res = await fetch(this.endpoint('/chat/completions'), {
                 method: 'POST',
                 headers: this.headers(),
@@ -376,6 +395,8 @@ class OpenAICompatProvider {
                 const { done, value } = await reader.read();
                 if (done)
                     break;
+                // Any chunk = the stream is alive: reset the idle clock.
+                armIdle();
                 buffer += decoder.decode(value, { stream: true });
                 const lines = buffer.split('\n');
                 buffer = lines.pop() || '';
@@ -390,7 +411,7 @@ class OpenAICompatProvider {
                         for (const r of tail.reasoning)
                             reasoning += r;
                         for (const c of tail.content)
-                            content += c;
+                            content = (0, provider_1.mergeStreamDelta)(content, c);
                         const calls = toolCollector.finished();
                         yield {
                             type: 'done',
@@ -428,7 +449,7 @@ class OpenAICompatProvider {
                             yield { type: 'delta', reasoning: r };
                         }
                         for (const c of pieces.content) {
-                            content += c;
+                            content = (0, provider_1.mergeStreamDelta)(content, c);
                             yield { type: 'delta', delta: c };
                         }
                     }
@@ -451,7 +472,7 @@ class OpenAICompatProvider {
             for (const r of tail.reasoning)
                 reasoning += r;
             for (const c of tail.content)
-                content += c;
+                content = (0, provider_1.mergeStreamDelta)(content, c);
             yield {
                 type: 'done',
                 result: {
@@ -463,8 +484,24 @@ class OpenAICompatProvider {
                 },
             };
         }
+        catch (err) {
+            // Distinguish a USER interrupt (outer signal aborted → keep the
+            // AbortError; the loop marks the run 'Stopped') from OUR deadline
+            // (idle/total timer fired → transport failure). The latter used to
+            // surface as a bare AbortError that withRetry refuses to retry, so
+            // one stalled stream killed the whole run mid-task; make it a
+            // retryable ProviderError instead.
+            if (params.signal?.aborted)
+                throw err;
+            if (err.name === 'AbortError') {
+                throw new provider_1.ProviderError('Upstream stream stalled (no data) — connection aborted by timeout.', 0, true);
+            }
+            throw err;
+        }
         finally {
             clearTimeout(timer);
+            if (idleTimer)
+                clearTimeout(idleTimer);
             if (params.signal)
                 params.signal.removeEventListener('abort', onOuterAbort);
         }

package/dist/providers/provider.js

@@ -1,21 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ProviderError = void 0;
+exports.mergeStreamDelta = mergeStreamDelta;
+exports.friendlyApiError = friendlyApiError;
 exports.withRetry = withRetry;
+/**
+ * Idempotent merge of a streamed delta into the reply content so far.
+ * Some OpenAI-compatible servers (e.g. BitDeer) resend the FULL text so far
+ * — or re-emit an identical chunk — on every stream frame instead of truly
+ * incremental deltas; a naive concatenation then renders the reply TWICE
+ * ("double chat", reported 2026-09-08: the final summary appeared twice —
+ * the TUI guarded its own display but the loop/provider accumulators did
+ * not, so done.result.content carried the doubled text). The guard is exact
+ * for all three shapes:
+ *   - trailing chunk resend  → keep (skip);
+ *   - full-text-so-far resend → replace;
+ *   - genuine incremental chunk → append.
+ */
+function mergeStreamDelta(existing, delta) {
+    if (!delta)
+        return existing;
+    if (existing.endsWith(delta))
+        return existing; // repeat of the trailing chunk
+    if (existing.startsWith(delta))
+        return existing; // earlier chunk re-emitted
+    if (delta.startsWith(existing))
+        return delta; // full text so far, resent
+    return existing + delta; // incremental chunk
+}
 /** Error thrown by providers for user-facing issues. */
 class ProviderError extends Error {
     status;
     retryable;
     constructor(message, status, retryable = false) {
-        super(message);
+        super(message
+            // Upstream error bodies are often PRETTY-PRINTED JSON — the raw
+            // text carries real newlines (e.g. `HTTP 429: {\n  "error": …}`).
+            // Every UI surface that prints an error is a SINGLE frame row (the
+            // bottom status bar, the Working line); a newline inside the text
+            // wraps the terminal there and the row "tembus ke bawah" — it
+            // overflows past the frame and pushes/prints over the rows below.
+            // Flatten any newline run to one space at the single chokepoint so
+            // every provider error is one-line by construction.
+            .replace(/\s*[\r\n]+\s*/g, ' ')
+            .trim());
         this.status = status;
         this.retryable = retryable;
         this.name = 'ProviderError';
     }
 }
 exports.ProviderError = ProviderError;
+/**
+ * Friendly one-line text for UI surfaces (status bar, chat error line).
+ * Raw provider bodies are NOT user-facing: a gateway 429 body like
+ * `HTTP 429: { "error": "provider key cooling down…" }` leaked internals
+ * into the status bar and ate the right side (timer/YOLO truncated).
+ * Mapping: known statuses get short human labels; JSON bodies are cut at
+ * the first `{`; leftover `HTTP <code>:` prefixes are dropped; the result
+ * is capped so the row always fits.
+ */
+function friendlyApiError(err) {
+    const status = err instanceof ProviderError ? err.status : undefined;
+    const raw = (err instanceof Error ? err.message : String(err)) || 'unknown error';
+    const labelByStatus = {
+        400: 'bad request',
+        401: 'auth failed — check API key',
+        402: 'quota/billing',
+        403: 'access denied',
+        404: 'model not found',
+        408: 'timeout',
+        429: 'provider busy (rate limit)',
+        500: 'provider error',
+        502: 'provider error',
+        503: 'provider unavailable',
+        504: 'timeout',
+    };
+    if (status !== undefined && labelByStatus[status])
+        return labelByStatus[status];
+    // Cut at the first `{` — everything from there on is a body dump.
+    const noJson = raw.split('{')[0].trim();
+    // Drop redundant `HTTP <code>:` / `<Name> HTTP <code>:` prefixes — the
+    // caller already shows the context ("Retrying x/y", "! Error:").
+    const cleaned = noJson.replace(/^(?:\w+ )?HTTP \d+(?: from \/\w+)?[—:-]\s*/i, '').trim();
+    const text = cleaned || noJson || raw;
+    return text.length > 64 ? `${text.slice(0, 63)}…` : text;
+}
 /** Simple retry wrapper for provider calls. */
-async function withRetry(fn, { retries = 3, delayMs = 1000, signal } = {}) {
+async function withRetry(fn, { retries = 3, delayMs = 1000, signal, 
+/** Called before each wait so the UI can show "retrying…" instead of a
+ * silent frozen spinner (retry waits are 1s/2s/4s — long enough to look
+ * like a hang when the stream just died mid-response). */
+onRetry, } = {}) {
     let attempt = 0;
     for (;;) {
         try {
@@ -31,6 +106,7 @@ async function withRetry(fn, { retries = 3, delayMs = 1000, signal } = {}) {
             if (!retryable || attempt > retries)
                 throw err;
             const wait = delayMs * Math.pow(2, attempt - 1);
+            onRetry?.(attempt, err, wait);
             await new Promise((r) => setTimeout(r, wait));
             if (signal?.aborted)
                 throw new Error('aborted');

package/dist/tools/design-lab.js

@@ -0,0 +1,247 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDesignLabTools = createDesignLabTools;
+const free_tier_1 = require("../config/free-tier");
+const BASE = free_tier_1.FREE_GATEWAY_URL.replace(/\/v1$/, '');
+const RUN_URL = BASE + '/v1/design/run';
+const STATUS_URL = (job) => BASE + '/v1/design/status/' + encodeURIComponent(job);
+const RESULT_URL = (job, json) => BASE + '/v1/design/result/' + encodeURIComponent(job) + (json ? '?format=json' : '');
+/** Polling status: tiap 20s, maks 8 menit (estimasi pipeline 4-6 menit + buffer).
+ * Interval/timeout bisa dipendekkan via env (dipakai test): VECTOR_DESIGN_POLL_MS,
+ * VECTOR_DESIGN_POLL_TIMEOUT_MS. */
+const POLL_INTERVAL_MS = Math.max(250, Number(process.env.VECTOR_DESIGN_POLL_MS) || 20_000);
+const POLL_TIMEOUT_MS = Math.max(1_000, Number(process.env.VECTOR_DESIGN_POLL_TIMEOUT_MS) || 8 * 60 * 1000);
+const BRIEF_MIN = 10;
+const BRIEF_MAX = 4000;
+const TERMINAL = new Set(['done', 'failed', 'expired', 'lost']);
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function fetchJson(url, init) {
+    const res = await fetch(url, {
+        ...init,
+        headers: { 'Content-Type': 'application/json', ...(init?.headers || {}) },
+        signal: AbortSignal.timeout(30_000),
+    });
+    let data = null;
+    try {
+        data = await res.json();
+    }
+    catch {
+        /* body non-JSON dibiarkan null */
+    }
+    return { status: res.status, data };
+}
+async function runAction(args) {
+    const brief = String(args.brief ?? '').trim();
+    if (brief.length < BRIEF_MIN) {
+        return { output: `ERROR: brief terlalu pendek (min ${BRIEF_MIN} karakter).` };
+    }
+    if (brief.length > BRIEF_MAX) {
+        return { output: `ERROR: brief terlalu panjang (maks ${BRIEF_MAX} karakter).` };
+    }
+    let r;
+    try {
+        r = await fetchJson(RUN_URL, { method: 'POST', body: JSON.stringify({ brief }) });
+    }
+    catch (e) {
+        return { output: `ERROR: gateway tidak terjangkau: ${e.message}` };
+    }
+    if (r.status === 429) {
+        const busy = r.data && r.data.busy ? ' job lain masih berjalan' : '';
+        return {
+            output: `ERROR: design-lab menolak (429)${busy}. ` +
+                `Coba lagi nanti — batas ${r.data && r.data.error && /rate limit/.test(String(r.data.error)) ? '5 job/jam' : '1 job aktif'}.` +
+                (r.data && Array.isArray(r.data.jobs) && r.data.jobs.length
+                    ? ` Job aktif: ${r.data.jobs.join(', ')} (cek dengan aksi "status").`
+                    : ''),
+        };
+    }
+    if (r.status !== 200) {
+        const detail = r.data && r.data.error ? r.data.error : `HTTP ${r.status}`;
+        return { output: `ERROR: /v1/design/run gagal: ${detail}` };
+    }
+    const job = r.data && r.data.job;
+    if (!job)
+        return { output: `ERROR: respons gateway tanpa job id: ${JSON.stringify(r.data).slice(0, 200)}` };
+    return {
+        output: `design-lab job ${job} dibuat (codespace: ${r.data.codespace || '?'}). ` +
+            `Pipeline berjalan ±4-6 menit. Pantau dengan aksi "status" job=${job}.`,
+        summary: `design job ${job} dibuat`,
+        data: { job, codespace: r.data.codespace, statusUrl: r.data.statusUrl, resultUrl: r.data.resultUrl },
+    };
+}
+async function statusAction(args) {
+    const job = String(args.job ?? '').trim();
+    if (!/^[a-z0-9-]{4,64}$/.test(job))
+        return { output: 'ERROR: job id tidak valid.' };
+    const wait = args.wait === true;
+    const deadline = Date.now() + POLL_TIMEOUT_MS;
+    let last = null;
+    for (;;) {
+        try {
+            last = await fetchJson(STATUS_URL(job));
+        }
+        catch (e) {
+            return { output: `ERROR: gateway tidak terjangkau: ${e.message}` };
+        }
+        if (last.status === 404) {
+            return { output: `ERROR: job ${job} tidak ditemukan / kedaluwarsa di gateway.` };
+        }
+        const state = last.data && last.data.state;
+        if (TERMINAL.has(state) || !wait || Date.now() >= deadline)
+            break;
+        await sleep(POLL_INTERVAL_MS);
+    }
+    if (!last)
+        return { output: 'ERROR: tidak ada respons dari gateway.' };
+    const d = last.data || {};
+    if (d.state === 'running') {
+        return {
+            output: `job ${job} masih running (codespace: ${d.codespaceState || '?'}). Panggil lagi nanti.`,
+            summary: `design job ${job}: running`,
+            data: d,
+        };
+    }
+    if (d.state === 'done') {
+        return {
+            output: `job ${job} SELESAI. Model: ${d.result?.model || '?'}, bytes: ${d.result?.bytes || '?'}. ` +
+                `Ambil hasil dengan aksi "result" job=${job}.`,
+            summary: `design job ${job}: done ✓`,
+            data: d,
+        };
+    }
+    // failed / expired / lost
+    const why = d.error || d.result?.error || '(tanpa detail)';
+    const hint = d.state === 'expired'
+        ? ' Melewati TTL 30 menit — hasil bisa saja tetap ter-push ke branch GitHub; cek repo skill.'
+        : d.state === 'lost'
+            ? ' Codespace hilang tanpa hasil.'
+            : '';
+    return {
+        output: `job ${job} berakhir dengan state=${d.state}. ${why}${hint}`,
+        summary: `design job ${job}: ${d.state}`,
+        data: d,
+    };
+}
+async function resultAction(args, ctx) {
+    const job = String(args.job ?? '').trim();
+    if (!/^[a-z0-9-]{4,64}$/.test(job))
+        return { output: 'ERROR: job id tidak valid.' };
+    const saveTo = String(args.save_to ?? '').trim();
+    let res;
+    try {
+        // Selalu format=json agar struktur respons seragam (indexHtml + result).
+        res = await fetch(RESULT_URL(job, true), { signal: AbortSignal.timeout(60_000) });
+    }
+    catch (e) {
+        return { output: `ERROR: gateway tidak terjangkau: ${e.message}` };
+    }
+    if (res.status === 404) {
+        return { output: `ERROR: hasil job ${job} tidak ditemukan (belum done / kedaluwarsa).` };
+    }
+    if (!res.ok)
+        return { output: `ERROR: /v1/design/result HTTP ${res.status}` };
+    const jj = await res.json();
+    const html = String(jj.indexHtml || '');
+    if (!html)
+        return { output: `ERROR: hasil job ${job} kosong.` };
+    if (saveTo) {
+        // Simpan hanya di dalam project root ctx.cwd (anti path-traversal) —
+        // konsisten dgn tool file lain (bukan process.cwd() proses CLI).
+        const path = await Promise.resolve().then(() => __importStar(require('node:path')));
+        const fs = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
+        const root = ctx ? ctx.cwd : process.cwd();
+        const target = path.resolve(root, saveTo);
+        if (!target.startsWith(root + path.sep) && target !== root) {
+            return { output: `ERROR: save_to harus di dalam project (diterima: ${saveTo}).` };
+        }
+        await fs.mkdir(path.dirname(target), { recursive: true });
+        await fs.writeFile(target, html, 'utf8');
+        return {
+            output: `hasil job ${job} (${html.length} byte) disimpan ke ${saveTo}` +
+                (/<\/html>\s*$/i.test(html) ? '' : ' — PERINGATAN: HTML tidak berakhir </html> (kemungkinan terpotong).'),
+            summary: `design job ${job}: disimpan ${saveTo}`,
+            data: { job, savedTo: saveTo, bytes: html.length, complete: /<\/html>\s*$/i.test(html) },
+        };
+    }
+    const head = html.slice(0, 1500);
+    return {
+        output: `hasil job ${job} (${html.length} byte):\n` +
+            (/<\/html>\s*$/i.test(html) ? '(HTML tampak lengkap)\n' : 'PERINGATAN: HTML TIDAK berakhir </html> — kemungkinan terpotong!\n') +
+            head +
+            (html.length > 1500 ? '\n…[dipotong — gunakan save_to untuk menyimpan file utuh]' : ''),
+        summary: `design job ${job}: ${html.length} byte`,
+        data: { job, bytes: html.length, complete: /<\/html>\s*$/i.test(html), indexHtml: html },
+    };
+}
+function createDesignLabTools() {
+    return [
+        {
+            definition: {
+                name: 'design_lab',
+                description: 'Run the remote design-lab pipeline (GitHub Codespace + ui-ux-pro-max skill) via the VectorHead gateway. ' +
+                    'Actions: "run" {brief} starts a one-file HTML design job (4-6 min, 1 concurrent job, 5 jobs/hour); ' +
+                    '"status" {job, wait?} polls until done/failed/expired/lost (wait=true blocks up to 8 min); ' +
+                    '"result" {job, save_to?} fetches the finished index.html (save_to writes it into the project). ' +
+                    'Use when the user asks for a landing page / one-file HTML design produced by the design-lab pipeline.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        action: { type: 'string', enum: ['run', 'status', 'result'], description: 'Which design-lab step to perform' },
+                        brief: { type: 'string', description: 'Design brief (action "run", 10-4000 chars)' },
+                        job: { type: 'string', description: 'Job id from a previous "run" (actions "status"/"result")' },
+                        wait: { type: 'boolean', description: 'action "status": block and poll until terminal state (default false)' },
+                        save_to: { type: 'string', description: 'action "result": project-relative path to save index.html (e.g. "output/index.html")' },
+                    },
+                    required: ['action'],
+                },
+            },
+            async execute(args, ctx) {
+                switch (args.action) {
+                    case 'run':
+                        return runAction(args);
+                    case 'status':
+                        return statusAction(args);
+                    case 'result':
+                        return resultAction(args, ctx);
+                    default:
+                        return { output: 'ERROR: action harus salah satu dari "run" | "status" | "result".' };
+                }
+            },
+        },
+    ];
+}