agentlas 1.0.65 → 1.0.67

package/engine/agentlas-api-agent.cjs

@@ -74,12 +74,18 @@ async function streamAnthropic({ apiKey, model, system, messages, permission, ui
   if (toolDefs.length) body.tools = toolDefs;
 
   const idle = idleAbort(signal, IDLE_MS);
-  const resp = await fetch("https://api.anthropic.com/v1/messages", {
-    method: "POST",
-    headers: { "content-type": "application/json", "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
-    signal: idle.signal,
-    body: JSON.stringify(body),
-  });
+  let resp;
+  try {
+    resp = await fetch("https://api.anthropic.com/v1/messages", {
+      method: "POST",
+      headers: { "content-type": "application/json", "x-api-key": apiKey, "anthropic-version": "2023-06-01" },
+      signal: idle.signal,
+      body: JSON.stringify(body),
+    });
+  } catch (error) {
+    idle.clear();
+    throw error;
+  }
   if (!resp.ok) {
     idle.clear();
     throw new Error(`Anthropic ${resp.status}: ${(await resp.text().catch(() => "")).slice(0, 300)}`);
@@ -88,45 +94,49 @@ async function streamAnthropic({ apiKey, model, system, messages, permission, ui
   const blocks = {}; // index → {type, text, name, id, inputJson}
   let stopReason = null;
   let usage = null;
-  for await (const line of iterSse(resp, idle)) {
-    const data = sseData(line);
-    if (!data || data === "[DONE]") continue;
-    let ev;
-    try {
-      ev = JSON.parse(data);
-    } catch {
-      continue;
-    }
-    if (ev.type === "content_block_start") {
-      const cb = ev.content_block || {};
-      blocks[ev.index] = { type: cb.type, text: "", name: cb.name, id: cb.id, inputJson: "" };
-      if (cb.type === "tool_use") ui.tool(cb.name, "");
-      else ui.streamStart();
-    } else if (ev.type === "content_block_delta") {
-      const b = blocks[ev.index] || (blocks[ev.index] = { type: "text", text: "", inputJson: "" });
-      if (ev.delta.type === "text_delta") {
-        b.text += ev.delta.text;
-        ui.streamDelta(ev.delta.text);
-      } else if (ev.delta.type === "input_json_delta") {
-        b.inputJson += ev.delta.partial_json || "";
+  try {
+    for await (const line of iterSse(resp, idle)) {
+      const data = sseData(line);
+      if (!data || data === "[DONE]") continue;
+      let ev;
+      try {
+        ev = JSON.parse(data);
+      } catch {
+        continue;
       }
-    } else if (ev.type === "content_block_stop") {
-      const b = blocks[ev.index];
-      if (b && b.type === "tool_use") {
-        const arg = safeArg(b.inputJson);
-        if (arg) ui.info(ui.c.dim("  " + arg));
+      if (ev.type === "content_block_start") {
+        const cb = ev.content_block || {};
+        blocks[ev.index] = { type: cb.type, text: "", name: cb.name, id: cb.id, inputJson: "" };
+        if (cb.type === "tool_use") ui.tool(cb.name, "");
+        else ui.streamStart();
+      } else if (ev.type === "content_block_delta") {
+        const b = blocks[ev.index] || (blocks[ev.index] = { type: "text", text: "", inputJson: "" });
+        if (ev.delta.type === "text_delta") {
+          b.text += ev.delta.text;
+          ui.streamDelta(ev.delta.text);
+        } else if (ev.delta.type === "input_json_delta") {
+          b.inputJson += ev.delta.partial_json || "";
+        }
+      } else if (ev.type === "content_block_stop") {
+        const b = blocks[ev.index];
+        if (b && b.type === "tool_use") {
+          const arg = safeArg(b.inputJson);
+          if (arg) ui.info(ui.c.dim("  " + arg));
+        }
+        // 텍스트 블록 stop에서는 streamEnd를 호출하지 않는다 — 메모리 가드 중간 flush 방지(턴 끝에서만 flush).
+      } else if (ev.type === "message_start") {
+        const u = ev.message && ev.message.usage;
+        if (u) usage = { input_tokens: u.input_tokens || 0, output_tokens: u.output_tokens || 0 };
+      } else if (ev.type === "message_delta") {
+        if (ev.delta && ev.delta.stop_reason) stopReason = ev.delta.stop_reason;
+        if (ev.usage) usage = { input_tokens: (usage && usage.input_tokens) || 0, output_tokens: ev.usage.output_tokens };
       }
-      // 텍스트 블록 stop에서는 streamEnd를 호출하지 않는다 — 메모리 가드 중간 flush 방지(턴 끝에서만 flush).
-    } else if (ev.type === "message_start") {
-      const u = ev.message && ev.message.usage;
-      if (u) usage = { input_tokens: u.input_tokens || 0, output_tokens: u.output_tokens || 0 };
-    } else if (ev.type === "message_delta") {
-      if (ev.delta && ev.delta.stop_reason) stopReason = ev.delta.stop_reason;
-      if (ev.usage) usage = { input_tokens: (usage && usage.input_tokens) || 0, output_tokens: ev.usage.output_tokens };
     }
+  } finally {
+    // 본문 스트림이 중간에 끊겨도 Renderer의 열린 스트림 상태와 취소 리스너를 남기지 않는다.
+    ui.streamEnd();
+    idle.clear();
   }
-  ui.streamEnd();
-  idle.clear();
 
   // 어셈블
   const ordered = Object.keys(blocks)
@@ -192,12 +202,18 @@ async function streamOpenAI({ apiKey, model, messages, permission, ui, signal, b
   if (toolDefs.length) body.tools = toolDefs;
 
   const idle = idleAbort(signal, IDLE_MS);
-  const resp = await fetch(`${baseUrl || "https://api.openai.com/v1"}/chat/completions`, {
-    method: "POST",
-    headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
-    signal: idle.signal,
-    body: JSON.stringify(body),
-  });
+  let resp;
+  try {
+    resp = await fetch(`${baseUrl || "https://api.openai.com/v1"}/chat/completions`, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${apiKey}` },
+      signal: idle.signal,
+      body: JSON.stringify(body),
+    });
+  } catch (error) {
+    idle.clear();
+    throw error;
+  }
   if (!resp.ok) {
     idle.clear();
     throw new Error(`OpenAI ${resp.status}: ${(await resp.text().catch(() => "")).slice(0, 300)}`);
@@ -208,43 +224,46 @@ async function streamOpenAI({ apiKey, model, messages, permission, ui, signal, b
   const toolCalls = {}; // index → {id, name, args}
   let finish = null;
   let usage = null;
-  for await (const line of iterSse(resp, idle)) {
-    const data = sseData(line);
-    if (!data || data === "[DONE]") continue;
-    let ev;
-    try {
-      ev = JSON.parse(data);
-    } catch {
-      continue;
-    }
-    if (ev.usage) usage = { input_tokens: ev.usage.prompt_tokens || 0, output_tokens: ev.usage.completion_tokens || 0 };
-    const choice = ev.choices && ev.choices[0];
-    if (!choice) continue;
-    const delta = choice.delta || {};
-    if (delta.content) {
-      if (!started) {
-        ui.streamStart();
-        started = true;
+  try {
+    for await (const line of iterSse(resp, idle)) {
+      const data = sseData(line);
+      if (!data || data === "[DONE]") continue;
+      let ev;
+      try {
+        ev = JSON.parse(data);
+      } catch {
+        continue;
       }
-      text += delta.content;
-      ui.streamDelta(delta.content);
-    }
-    if (Array.isArray(delta.tool_calls)) {
-      for (const tc of delta.tool_calls) {
-        const idx = tc.index ?? 0;
-        const cur = toolCalls[idx] || (toolCalls[idx] = { id: "", name: "", args: "" });
-        if (tc.id) cur.id = tc.id;
-        if (tc.function && tc.function.name) {
-          if (!cur.name) ui.tool(tc.function.name, "");
-          cur.name = tc.function.name;
+      if (ev.usage) usage = { input_tokens: ev.usage.prompt_tokens || 0, output_tokens: ev.usage.completion_tokens || 0 };
+      const choice = ev.choices && ev.choices[0];
+      if (!choice) continue;
+      const delta = choice.delta || {};
+      if (delta.content) {
+        if (!started) {
+          ui.streamStart();
+          started = true;
+        }
+        text += delta.content;
+        ui.streamDelta(delta.content);
+      }
+      if (Array.isArray(delta.tool_calls)) {
+        for (const tc of delta.tool_calls) {
+          const idx = tc.index ?? 0;
+          const cur = toolCalls[idx] || (toolCalls[idx] = { id: "", name: "", args: "" });
+          if (tc.id) cur.id = tc.id;
+          if (tc.function && tc.function.name) {
+            if (!cur.name) ui.tool(tc.function.name, "");
+            cur.name = tc.function.name;
+          }
+          if (tc.function && tc.function.arguments) cur.args += tc.function.arguments;
         }
-        if (tc.function && tc.function.arguments) cur.args += tc.function.arguments;
       }
+      if (choice.finish_reason) finish = choice.finish_reason;
     }
-    if (choice.finish_reason) finish = choice.finish_reason;
+  } finally {
+    if (started) ui.streamEnd();
+    idle.clear();
   }
-  if (started) ui.streamEnd();
-  idle.clear();
 
   const calls = Object.keys(toolCalls)
     .sort((a, b) => a - b)
@@ -327,26 +346,29 @@ async function runOllamaLoop(req) {
     let text = "";
     let started = false;
     let toolCalls = [];
-    for await (const line of iterSse(resp, idle)) {
-      let ev;
-      try {
-        ev = JSON.parse(line);
-      } catch {
-        continue;
-      }
-      const msg = ev.message || {};
-      if (msg.content) {
-        if (!started) {
-          ui.streamStart();
-          started = true;
+    try {
+      for await (const line of iterSse(resp, idle)) {
+        let ev;
+        try {
+          ev = JSON.parse(line);
+        } catch {
+          continue;
         }
-        text += msg.content;
-        ui.streamDelta(msg.content);
+        const msg = ev.message || {};
+        if (msg.content) {
+          if (!started) {
+            ui.streamStart();
+            started = true;
+          }
+          text += msg.content;
+          ui.streamDelta(msg.content);
+        }
+        if (Array.isArray(msg.tool_calls)) toolCalls = toolCalls.concat(msg.tool_calls);
       }
-      if (Array.isArray(msg.tool_calls)) toolCalls = toolCalls.concat(msg.tool_calls);
+    } finally {
+      if (started) ui.streamEnd();
+      idle.clear();
     }
-    if (started) ui.streamEnd();
-    idle.clear();
     finalText = text || finalText;
     if (!toolCalls.length) break;
     messages.push({ role: "assistant", content: text, tool_calls: toolCalls });
@@ -373,39 +395,48 @@ async function runGoogleChat(req) {
   }
   const url = `https://generativelanguage.googleapis.com/v1beta/models/${req.model}:streamGenerateContent?alt=sse&key=${encodeURIComponent(req.apiKey)}`;
   const idle = idleAbort(req.signal, IDLE_MS);
-  const resp = await fetch(url, {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    signal: idle.signal,
-    body: JSON.stringify({ systemInstruction: { parts: [{ text: req.system }] }, contents }),
-  });
+  let resp;
+  try {
+    resp = await fetch(url, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      signal: idle.signal,
+      body: JSON.stringify({ systemInstruction: { parts: [{ text: req.system }] }, contents }),
+    });
+  } catch (error) {
+    idle.clear();
+    throw error;
+  }
   if (!resp.ok) {
     idle.clear();
     throw new Error(`Google ${resp.status}: ${(await resp.text().catch(() => "")).slice(0, 300)}`);
   }
   let text = "";
   let started = false;
-  for await (const line of iterSse(resp, idle)) {
-    const data = sseData(line);
-    if (!data || data === "[DONE]") continue;
-    let ev;
-    try {
-      ev = JSON.parse(data);
-    } catch {
-      continue;
-    }
-    const t = ev.candidates && ev.candidates[0] && ev.candidates[0].content && ev.candidates[0].content.parts && ev.candidates[0].content.parts[0] && ev.candidates[0].content.parts[0].text;
-    if (t) {
-      if (!started) {
-        ui.streamStart();
-        started = true;
+  try {
+    for await (const line of iterSse(resp, idle)) {
+      const data = sseData(line);
+      if (!data || data === "[DONE]") continue;
+      let ev;
+      try {
+        ev = JSON.parse(data);
+      } catch {
+        continue;
+      }
+      const t = ev.candidates && ev.candidates[0] && ev.candidates[0].content && ev.candidates[0].content.parts && ev.candidates[0].content.parts[0] && ev.candidates[0].content.parts[0].text;
+      if (t) {
+        if (!started) {
+          ui.streamStart();
+          started = true;
+        }
+        text += t;
+        ui.streamDelta(t);
       }
-      text += t;
-      ui.streamDelta(t);
     }
+  } finally {
+    if (started) ui.streamEnd();
+    idle.clear();
   }
-  if (started) ui.streamEnd();
-  idle.clear();
   return { text };
 }
 

package/engine/agentlas-banner.cjs

@@ -163,8 +163,12 @@ function cardBottom(label, inner, c) {
 function renderCompactSplash(ui, value, room) {
   const c = ui.c;
   const version = value.version ? "  v" + value.version : "";
+  const title = truncateWidth(
+    WORDMARK_COMPACT + version + "  ·  " + ui.t("banner.product"),
+    Math.max(1, room),
+  );
   ui.line("");
-  ui.line(CARD_MARGIN + c.bold(c.emerald(WORDMARK_COMPACT)) + c.faint(version) + c.dim("  ·  " + ui.t("banner.product")));
+  ui.line(CARD_MARGIN + c.bold(c.emerald(title)));
   ui.line(CARD_MARGIN + c.text(truncateWidth(ui.t("banner.session", value.runtime, value.subject, value.permission), room)));
   ui.line(CARD_MARGIN + c.faint(truncateWidth(ui.t("banner.location", value.cwd), room)));
   ui.line("");
@@ -186,7 +190,7 @@ function renderBanner(ctx) {
   const columns = ui.out.columns || 80;
   const inner = Math.min(CARD_MAX_INNER, columns - visWidth(CARD_MARGIN) * 2 - 2);
   if (inner < CARD_MIN_INNER) {
-    renderCompactSplash(ui, value, Math.max(20, columns - 4));
+    renderCompactSplash(ui, value, Math.max(1, columns - visWidth(CARD_MARGIN)));
     return;
   }
 

package/engine/agentlas-capabilities.cjs

@@ -24,22 +24,27 @@ const RUNTIME_CAPS = {
   upstage: { code: true, image: false, label: "solar" }, // Upstage Solar — Korean sovereign LLM (OpenAI-compatible)
 };
 
-// NOTE: grok은 CAPS(멀티모달 능력 인지)만 등록 — 터미널 스폰 러너(RUNTIME_BIN)가 아직 없어
-// CLI_KINDS에 넣으면 repl의 which(RUNTIME_BIN[k]) 탐지가 깨진다. 러너 추가 시 함께 확장할 것.
-// 목록의 정본은 runtimes/kinds.cjs — 여기서는 네이티브 스폰 러너 4종만 가져다 쓴다.
-const CLI_KINDS = require("./runtimes/kinds.cjs").NATIVE_CLI_KINDS;
+// 목록·별칭의 정본은 runtimes/kinds.cjs다. ACP 공용 러너가 추가된 뒤에도 이 파일이
+// 옛 native 4종만 보아 grok/kimi/cursor를 API backend로 잘못 만들지 않게 한다.
+const KINDS = require("./runtimes/kinds.cjs");
+const CLI_KINDS = KINDS.CLI_KINDS;
+const API_SPECS = new Set(KINDS.API_BACKEND_SPECS);
 
 function capsFor(spec) {
-  return RUNTIME_CAPS[spec] || { code: true, image: false, label: spec || "?" };
+  const canonical = KINDS.canonicalRuntimeKind(spec);
+  return RUNTIME_CAPS[canonical] || { code: true, image: false, label: canonical || "?" };
 }
 
 // runtime object ⇄ spec string
 function specOf(rt) {
   if (!rt) return "";
-  return rt.mode === "cli" ? rt.kind : rt.backend;
+  return rt.mode === "cli" ? KINDS.canonicalRuntimeKind(rt.kind) : rt.backend;
 }
 function runtimeFromSpec(spec) {
-  return CLI_KINDS.includes(spec) ? { mode: "cli", kind: spec } : { mode: "api", backend: spec, model: null };
+  const canonical = KINDS.canonicalRuntimeKind(spec);
+  if (CLI_KINDS.includes(canonical)) return { mode: "cli", kind: canonical };
+  if (API_SPECS.has(canonical)) return { mode: "api", backend: canonical, model: null };
+  return null;
 }
 
 // Image capability is judged only by the connected model from the complete
@@ -116,10 +121,12 @@ function clearImageJudgments() {
 // Image agents route to an installed image-capable runtime; otherwise keep the session default.
 function autoRuntimeFor(agent, { installedKinds, activeSpec }) {
   if (needsImage(agent)) {
-    if (capsFor(activeSpec).image) return activeSpec;
-    for (const k of ["agy", "gemini", "codex"]) if ((installedKinds || []).includes(k)) return k;
+    const canonicalActive = KINDS.canonicalRuntimeKind(activeSpec);
+    if (capsFor(canonicalActive).image) return canonicalActive;
+    const installed = new Set((installedKinds || []).map(KINDS.canonicalRuntimeKind));
+    for (const k of ["agy", "gemini", "codex"]) if (installed.has(k)) return k;
   }
-  return activeSpec;
+  return KINDS.canonicalRuntimeKind(activeSpec);
 }
 
 // short capability badge for display

package/engine/agentlas-cloud-runtime.cjs

@@ -4,10 +4,9 @@ const fs = require("node:fs");
 const path = require("node:path");
 const os = require("node:os");
 const crypto = require("node:crypto");
+const { looksSecret, redactSecrets } = require("./agentlas-secret-patterns.cjs");
 
 const TEXT_EXTS = new Set([".md", ".txt", ".json", ".jsonl", ".yaml", ".yml", ".toml", ".js", ".ts", ".tsx", ".cjs", ".mjs", ".sh"]);
-const SECRET_RE = /(sk-(?:ant-)?[A-Za-z0-9_-]{20,}|gh[opsu]_[A-Za-z0-9_]{20,}|AKIA[0-9A-Z]{16}|AIza[0-9A-Za-z_-]{35}|-----BEGIN (?:RSA |EC |OPENSSH )?PRIVATE KEY-----)/;
-const SECRET_ASSIGN_RE = /\b(?:api[_-]?key|secret|password|token)\s*[:=]\s*["']?([A-Za-z0-9+/=_-]{20,})["']?/i;
 const PROMPT_INJECTION_RE = /\b(ignore (?:all |previous |prior )?instructions|reveal (?:your )?system prompt|print hidden instructions)\b/i;
 const DESTRUCTIVE_RE = /\b(rm\s+-rf\s+(?:\/|~)|curl\b[^\n]{0,240}\|\s*(?:sudo\s+)?(?:sh|bash|zsh)|mkfs\.|dd\s+if=\/dev\/)\b/i;
 
@@ -133,7 +132,7 @@ function buildManifest(root, options = {}) {
 }
 
 function redact(text) {
-  return text.replace(SECRET_RE, "[REDACTED_SECRET]").replace(SECRET_ASSIGN_RE, (match, secret) => match.replace(secret, "[REDACTED_SECRET]"));
+  return redactSecrets(text, "[REDACTED_SECRET]");
 }
 
 function scanFiles(files) {
@@ -146,13 +145,13 @@ function scanFiles(files) {
     // `/token|secret/i` test blocked ordinary vocabulary — measured 2026-07-29,
     // it gave the live `web-master` package a BLOCK verdict for its own design
     // system (`token-architecture.md`, `reference-token-db.json`). Dropping it
-    // costs no coverage: the per-line SECRET_PATTERNS scan below reads every
+    // costs no coverage: the shared per-line credential scan below reads every
     // packaged file and is the check that actually looks at values.
     if (/^\.env(\.|$)/.test(file.path.split("/").pop() || "") || /(?:^|\/)(secrets|credentials|cookies)\//i.test(file.path)) {
       add("BLOCK", "credential-path", file, null, "Credential-like file path is excluded from Cloud package and public publish.");
     }
     file.content.split(/\r?\n/).forEach((line, index) => {
-      if (SECRET_RE.test(line) || SECRET_ASSIGN_RE.test(line)) add("BLOCK", "secret-like-value", file, index + 1, "Secret-like value detected and redacted.");
+      if (looksSecret(line)) add("BLOCK", "secret-like-value", file, index + 1, "Secret-like value detected and redacted.");
       if (PROMPT_INJECTION_RE.test(line)) add("WARN", "prompt-injection", file, index + 1, "Prompt-injection style instruction needs review.");
       if (DESTRUCTIVE_RE.test(line)) add("WARN", "destructive-command", file, index + 1, "Destructive or remote shell command needs review before execution.");
     });

package/engine/agentlas-config.cjs

@@ -8,8 +8,11 @@
  */
 const fs = require("node:fs");
 const path = require("node:path");
-const LOCK_WAIT_MS = 2_000;
-const LOCK_STALE_MS = 30_000;
+const {
+  readJsonFile,
+  writePrivateJsonAtomic,
+  withPrivateStateLock,
+} = require("./mcp/contract.cjs");
 
 function prefsPath(userDataDir) {
   return path.join(userDataDir, "cli-prefs.json");
@@ -19,7 +22,7 @@ function backupPath(userDataDir) {
 }
 function readPrefsFile(file) {
   try {
-    const value = JSON.parse(fs.readFileSync(file, "utf8"));
+    const { value } = readJsonFile(file, "CLI preferences");
     return value && typeof value === "object" && !Array.isArray(value) ? value : null;
   } catch {
     return null;
@@ -29,60 +32,15 @@ function loadPrefs(userDataDir) {
   return readPrefsFile(prefsPath(userDataDir)) || readPrefsFile(backupPath(userDataDir)) || {};
 }
 
-function sleepSync(ms) {
-  try {
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-  } catch {
-    const until = Date.now() + ms;
-    while (Date.now() < until) { /* old Node fallback */ }
-  }
-}
-
 function withPrefsLock(userDataDir, callback) {
-  const lock = prefsPath(userDataDir) + ".lock";
-  const deadline = Date.now() + LOCK_WAIT_MS;
-  while (true) {
-    try {
-      fs.mkdirSync(lock, { mode: 0o700 });
-      break;
-    } catch (error) {
-      if (!error || error.code !== "EEXIST") throw error;
-      try {
-        if (Date.now() - fs.statSync(lock).mtimeMs > LOCK_STALE_MS) {
-          fs.rmdirSync(lock);
-          continue;
-        }
-      } catch {
-        continue;
-      }
-      if (Date.now() >= deadline) throw new Error("preferences lock timeout");
-      sleepSync(10);
-    }
-  }
-  try {
-    return callback();
-  } finally {
-    try { fs.rmdirSync(lock); } catch { /* stale lock recovery handles interrupted writers */ }
-  }
+  return withPrivateStateLock(prefsPath(userDataDir), {
+    unsafe: "preferences lock is unsafe",
+    busy: "preferences lock timeout",
+  }, callback);
 }
 
 function atomicWrite(file, value) {
-  const tmp = `${file}.${process.pid}.${Date.now()}.${Math.random().toString(16).slice(2)}.tmp`;
-  let fd;
-  try {
-    fd = fs.openSync(tmp, "wx", 0o600);
-    fs.writeFileSync(fd, JSON.stringify(value, null, 2), "utf8");
-    fs.fsyncSync(fd);
-    fs.closeSync(fd);
-    fd = null;
-    fs.renameSync(tmp, file);
-    try { fs.chmodSync(file, 0o600); } catch { /* win32 */ }
-  } finally {
-    if (fd != null) {
-      try { fs.closeSync(fd); } catch { /* ignore */ }
-    }
-    try { fs.unlinkSync(tmp); } catch { /* already renamed or never created */ }
-  }
+  writePrivateJsonAtomic(file, value);
 }
 
 function mergePrefs(base, patch) {
@@ -111,9 +69,16 @@ function updatePrefs(userDataDir, patch) {
   fs.mkdirSync(userDataDir, { recursive: true });
   return withPrefsLock(userDataDir, () => {
     const file = prefsPath(userDataDir);
+    let currentStat = null;
+    try { currentStat = fs.lstatSync(file); } catch (error) {
+      if (!error || error.code !== "ENOENT") throw error;
+    }
+    if (currentStat && (!currentStat.isFile() || currentStat.isSymbolicLink() || currentStat.nlink !== 1)) {
+      throw new Error("CLI preferences path is unsafe");
+    }
     const currentWasValid = Boolean(readPrefsFile(file));
     const current = loadPrefs(userDataDir);
-    if (fs.existsSync(file) && !currentWasValid) {
+    if (currentStat && !currentWasValid) {
       try { fs.renameSync(file, `${file}.corrupt-${Date.now()}-${process.pid}`); } catch { /* recover from backup */ }
     }
     const next = mergePrefs(current, patch);

package/engine/agentlas-core-harness.cjs

@@ -12,6 +12,8 @@ const HARNESS_ID = "agentlas-core/stormbreaker-goal-ultracode";
 const HARNESS_MODE = "stormbreaker-goal-ultracode";
 const CONTEXT_MAP_MIN_CORE_VERSION = "1.1.86";
 const CORE_MANIFEST_MAX_BYTES = 64 * 1024;
+const CORE_CAPTURE_MAX_BYTES = 16 * 1024 * 1024;
+const CORE_CAPTURE_TIMEOUT_MS = 120_000;
 const CORE_RUNTIME_MARKERS = [
   ["agentlas_cloud", "__main__.py"],
   ["schemas", "workforce-work-order.schema.json"],
@@ -222,13 +224,55 @@ async function captureCoreJson(moduleName, args, opts = {}, explicitRoot) {
   const child = spawnCoreModule(moduleName, args, { ...opts, stdio: ["ignore", "pipe", "pipe"] }, explicitRoot);
   if (!child) throw new Error("Agentlas Core runtime or Python 3.9+ is unavailable.");
   const result = await new Promise((resolve) => {
-    let stdout = "";
+    const stdoutChunks = [];
+    let stdoutBytes = 0;
     let stderr = "";
-    child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+    let outputExceeded = false;
+    let timedOut = false;
+    let settled = false;
+    let forceKill = null;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timeout);
+      if (forceKill) clearTimeout(forceKill);
+      resolve(value);
+    };
+    const terminate = () => {
+      try { child.kill("SIGTERM"); } catch { /* already gone */ }
+      if (!forceKill) {
+        forceKill = setTimeout(() => { try { child.kill("SIGKILL"); } catch { /* already gone */ } }, 250);
+        forceKill.unref?.();
+      }
+    };
+    const timeoutMs = Number.isFinite(Number(opts.timeout)) && Number(opts.timeout) > 0
+      ? Number(opts.timeout)
+      : CORE_CAPTURE_TIMEOUT_MS;
+    const timeout = setTimeout(() => { timedOut = true; terminate(); }, timeoutMs);
+    timeout.unref?.();
+    child.stdout.on("data", (chunk) => {
+      if (outputExceeded) return;
+      const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      stdoutBytes += bytes.length;
+      if (stdoutBytes > CORE_CAPTURE_MAX_BYTES) {
+        outputExceeded = true;
+        terminate();
+        return;
+      }
+      stdoutChunks.push(bytes);
+    });
     child.stderr.on("data", (chunk) => { stderr = (stderr + chunk.toString()).slice(-4000); });
-    child.on("error", (error) => resolve({ code: 1, stdout, stderr: String(error.message) }));
-    child.on("close", (code) => resolve({ code: code ?? 0, stdout, stderr }));
+    child.on("error", (error) => finish({ code: 1, stdout: "", stderr: String(error.message), outputExceeded, timedOut }));
+    child.on("close", (code) => finish({
+      code: code ?? 0,
+      stdout: outputExceeded ? "" : Buffer.concat(stdoutChunks, stdoutBytes).toString("utf8"),
+      stderr,
+      outputExceeded,
+      timedOut,
+    }));
   });
+  if (result.outputExceeded) throw new Error(`Agentlas Core ${moduleName} response exceeded ${CORE_CAPTURE_MAX_BYTES} bytes.`);
+  if (result.timedOut) throw new Error(`Agentlas Core ${moduleName} timed out after ${Number(opts.timeout) > 0 ? Number(opts.timeout) : CORE_CAPTURE_TIMEOUT_MS}ms.`);
   const json = parseJsonOutput(result.stdout);
   if (result.code !== 0 || !json) {
     throw new Error(result.stderr.trim() || `Agentlas Core ${moduleName} did not return JSON.`);
@@ -247,7 +291,8 @@ function captureCoreJsonSync(moduleName, args, opts = {}, explicitRoot) {
       ...opts,
       encoding: "utf8",
       windowsHide: true,
-      timeout: opts.timeout || 120_000,
+      maxBuffer: CORE_CAPTURE_MAX_BYTES,
+      timeout: opts.timeout || CORE_CAPTURE_TIMEOUT_MS,
       env: {
         ...(opts.env || process.env),
         HEPHAESTUS_RUNTIME_ROOT: root,
@@ -256,6 +301,13 @@ function captureCoreJsonSync(moduleName, args, opts = {}, explicitRoot) {
       },
     },
   );
+  if (result.error && result.error.code === "ENOBUFS") {
+    throw new Error(`Agentlas Core ${moduleName} response exceeded ${CORE_CAPTURE_MAX_BYTES} bytes.`);
+  }
+  if (result.error && result.error.code === "ETIMEDOUT") {
+    const timeoutMs = Number(opts.timeout) > 0 ? Number(opts.timeout) : CORE_CAPTURE_TIMEOUT_MS;
+    throw new Error(`Agentlas Core ${moduleName} timed out after ${timeoutMs}ms.`);
+  }
   const json = parseJsonOutput(result.stdout);
   if (result.status !== 0 || !json) {
     throw new Error(String(result.stderr || result.error?.message || `Agentlas Core ${moduleName} did not return JSON.`).trim());
@@ -279,6 +331,8 @@ module.exports = {
   HARNESS_MODE,
   CONTEXT_MAP_MIN_CORE_VERSION,
   CONTEXT_MAP_V3_RUNTIME_MARKERS,
+  CORE_CAPTURE_MAX_BYTES,
+  CORE_CAPTURE_TIMEOUT_MS,
   PY_BOOTSTRAP,
   readCoreRuntimeVersion,
   resolveCoreRuntimeRootFromCandidates,