agentlas 1.0.47 → 1.0.49

package/engine/project/memory-context.cjs

@@ -123,6 +123,13 @@ function cliProjectContextSlice(projectPath, task) {
         "--task-stdin",
         "--no-refresh",
         "--render",
+        // Recall degrades to a labelled map, never to nothing. Core's passive
+        // freshness check walks the whole repository (measured 11.0s on the
+        // pilot) against this 4s timeout, and any non-zero exit is swallowed
+        // into "" below — so without a budget a large project silently lost
+        // its slice on every turn.
+        "--allow-stale",
+        "--freshness-budget", "0.4",
       ],
       {
         cwd: projectPath,

package/engine/runtimes/acp-driver.cjs

@@ -0,0 +1,96 @@
+"use strict";
+/*
+ * runtimes/acp-driver — kimi · grok · cursor 를 위한 ACP 드라이버 (PRD 2026-08-15 T-2).
+ *
+ * 세 번째 손코딩이 아니다. Desktop 이 만든 공용 ACP 러너(electron/runtime/acp.js)를 벤더 코어에서
+ * 그대로 로드해 쓴다 — 데스크탑·터미널이 같은 파일 하나로 같은 런타임을 같은 품질로 돈다.
+ * (터미널이 손으로 미러링해 온 native-host 4종과 달리 드리프트가 구조적으로 없다.)
+ *
+ * 벤더 코어에 acp.js 가 없으면(옛 코어) — 종전 그대로 "드라이버 없음"으로 정직하게 거부한다.
+ * 조용히 다른 런타임으로 넘어가지 않는다.
+ */
+const { loadCoreAcpRuntime } = require("../core/desktop-core.cjs");
+
+// 정본(runtimes/kinds.cjs)의 ACP 3종에서 파생 — resolve.cjs의 ACP_CLI_KINDS와 같은 원소.
+const ACP_KINDS = new Set(require("./kinds.cjs").ACP_CLI_KINDS);
+
+/** 이 머신에서 ACP 드라이버를 쓸 수 있는가. { ok, reason?, module? } */
+function acpDriverAvailability() {
+  const loaded = loadCoreAcpRuntime();
+  if (!loaded) return { ok: false, reason: "desktop core not available (run `agentlas doctor`)" };
+  if (loaded.error) return { ok: false, reason: loaded.error.message };
+  if (!loaded.module || typeof loaded.module.createAcpRunner !== "function") {
+    return { ok: false, reason: "desktop core exposes no createAcpRunner" };
+  }
+  return { ok: true, module: loaded.module };
+}
+
+function acpSpecFor(kind, mod) {
+  const spec = mod.ACP_AGENTS && mod.ACP_AGENTS[kind];
+  return spec || null;
+}
+
+/**
+ * native-host 계약으로 ACP 턴을 돈다.
+ * req = { kind, bin, prompt, systemPrompt, cwd, permission, ui, env, signal, model, locale }
+ * 반환: { text, session, usage, error, errorKind, errorSource }
+ */
+async function runAcpTurn(req) {
+  const { kind, bin, ui } = req;
+  const avail = acpDriverAvailability();
+  if (!avail.ok) {
+    return { text: "", session: req.session || {}, error: `runtime '${kind}' has no ACP driver here: ${avail.reason}`, errorKind: "unsupported", errorSource: "marker" };
+  }
+  const mod = avail.module;
+  const spec = acpSpecFor(kind, mod);
+  if (!spec) {
+    return { text: "", session: req.session || {}, error: `runtime '${kind}' is not an ACP agent in this core`, errorKind: "unsupported", errorSource: "marker" };
+  }
+  const runner = mod.createAcpRunner(spec);
+  const locale = req.locale === "ko" ? "ko" : "en";
+  let streaming = false;
+  let lastText = "";
+  const events = {
+    onPartial: (full) => {
+      const text = String(full || "");
+      if (!streaming) { ui.streamStart(); streaming = true; }
+      const delta = text.startsWith(lastText) ? text.slice(lastText.length) : text;
+      lastText = text;
+      if (delta) ui.streamDelta(delta);
+    },
+    onStatus: (status) => ui.status(status),
+    onTool: (name, args, result, id, isError) => {
+      ui.tool(name, args || "");
+      if (result) ui.toolResult(result, !isError);
+    },
+    onThinking: (phase) => { if (phase === "start") ui.status(locale === "ko" ? "생각 중..." : "thinking..."); },
+    onNotice: (notice) => { if (notice && notice.message) ui.status(notice.message); },
+  };
+  try {
+    const result = await runner({
+      systemPrompt: req.systemPrompt || "",
+      history: [],
+      userPrompt: req.prompt || "",
+      backendLabel: spec.label,
+      locale,
+      permission: req.permission,
+      runtimeSource: bin,
+      cwd: req.cwd,
+      env: req.env || process.env,
+      signal: req.signal,
+      ...(req.model ? { model: req.model } : {}),
+    }, events);
+    if (streaming) ui.streamEnd();
+    const session = { ...(req.session || {}), ...(result.sessionId ? { acpSessionId: result.sessionId } : {}) };
+    if (result.failure) {
+      return { text: result.text || "", session, usage: null, error: result.failure.message, errorKind: result.failure.kind, errorSource: result.failure.source };
+    }
+    return { text: result.text || "", session, usage: null, error: null };
+  } catch (e) {
+    if (streaming) ui.streamEnd();
+    const message = e && e.message ? e.message : String(e);
+    return { text: "", session: req.session || {}, usage: null, error: message, errorKind: /abort/i.test(message) ? "cancelled" : "exit", errorSource: "marker" };
+  }
+}
+
+module.exports = { ACP_KINDS, acpDriverAvailability, acpSpecFor, runAcpTurn };

package/engine/runtimes/detect.cjs

@@ -7,20 +7,10 @@
  * (없으면 no_runtime 정직 정지 — 폴백 금지는 상위 계층의 계약).
  */
 const { spawnSync } = require("node:child_process");
+// kind 목록/실행 파일 이름의 정본은 runtimes/kinds.cjs 하나다 — 여기서 다시 적지 않는다.
+const { RUNTIME_BIN, CLI_KINDS } = require("./kinds.cjs");
 
-const RUNTIME_BIN = {
-  "claude-code": "claude",
-  codex: "codex",
-  // Antigravity CLI — gemini 후속. 공식 gemini CLI가 계정 티어로 죽어도(IneligibleTierError,
-  // 실측 2026-08-06) 이쪽은 산다. 데스크탑 gemini 러너의 agy 경로와 같은 실물.
-  agy: "agy",
-  gemini: "gemini",
-  kimi: "kimi",
-  grok: "grok",
-  cursor: "cursor-agent",
-};
-
-const CLI_RUNTIMES = Object.keys(RUNTIME_BIN);
+const CLI_RUNTIMES = CLI_KINDS;
 
 function whichSync(bin) {
   const cmd = process.platform === "win32" ? "where" : "which";

package/engine/runtimes/kinds.cjs

@@ -0,0 +1,84 @@
+"use strict";
+/*
+ * runtimes/kinds — 런타임 종류(RuntimeKind)의 단일 정본 (2026-08-18).
+ *
+ * 배경: 같은 어휘가 8곳(detect·capture·resolve·acp-driver·capabilities·onboard·
+ * palette·input)에 손 목록으로 흩어져 있었다 — 새 kind 를 추가하면 한두 곳이
+ * 반드시 빠진다. 여기 한 벌만 두고, 다른 표면은 이 상수를 **가져다 쓴다**.
+ * 좁은 목록(캡처 4종 등)도 정본에서 파생해야 새 kind 가 모든 표면에 보인다.
+ *
+ * 순서가 곧 계약이다:
+ *  - detect.listAvailableCliRuntimes 는 이 순서로 PATH 를 훑고, resolve 의
+ *    "detected" 폴백은 그 첫 항목을 쓴다.
+ *  - 온보딩 위저드 선택지·팔레트/입력 완성 후보도 이 순서로 표시된다.
+ */
+
+const RUNTIME_KIND_SPECS = [
+  { kind: "claude-code", bin: "claude", driver: "native", capture: true },
+  { kind: "codex", bin: "codex", driver: "native", capture: true },
+  // Antigravity CLI — gemini 후속. 공식 gemini CLI가 계정 티어로 죽어도(IneligibleTierError,
+  // 실측 2026-08-06) 이쪽은 산다. 데스크탑 gemini 러너의 agy 경로와 같은 실물.
+  { kind: "agy", bin: "agy", driver: "native", capture: true },
+  { kind: "gemini", bin: "gemini", driver: "native", capture: true },
+  // kimi/grok/cursor 는 ACP 드라이버(runtimes/acp-driver.cjs → 벤더 코어의 공용
+  // ACP 러너)로 돈다 (PRD 2026-08-15 T-2). 캡처(buildArgs/텍스트 추출) 계약은 없다.
+  { kind: "kimi", bin: "kimi", driver: "acp" },
+  { kind: "grok", bin: "grok", driver: "acp" },
+  { kind: "cursor", bin: "cursor-agent", driver: "acp" },
+];
+
+/** kind → 실행 파일 이름. CLI 런타임 전체(네이티브 + ACP). */
+const RUNTIME_BIN = Object.fromEntries(RUNTIME_KIND_SPECS.map((s) => [s.kind, s.bin]));
+
+/** CLI 런타임 kind 전체(탐지 순서). */
+const CLI_KINDS = RUNTIME_KIND_SPECS.map((s) => s.kind);
+
+/** native-host 드라이버(스폰 러너)를 갖춘 CLI 4종. */
+const NATIVE_CLI_KINDS = RUNTIME_KIND_SPECS.filter((s) => s.driver === "native").map((s) => s.kind);
+
+/** 벤더 코어의 공용 ACP 러너로 도는 3종. */
+const ACP_CLI_KINDS = RUNTIME_KIND_SPECS.filter((s) => s.driver === "acp").map((s) => s.kind);
+
+/** 캡처(no-authority headless) 드라이버가 검증된 kind — buildArgs/텍스트 추출 계약 보유. */
+const CAPTURE_CLI_KINDS = RUNTIME_KIND_SPECS.filter((s) => s.capture).map((s) => s.kind);
+
+/** kind → bin, 캡처 검증본만. workforce/capture 가 쓴다. */
+const CAPTURE_RUNTIME_BIN = Object.fromEntries(
+  RUNTIME_KIND_SPECS.filter((s) => s.capture).map((s) => [s.kind, s.bin]),
+);
+
+/** CLI 가 아니라 로컬 API loop 로 실행되는 kind. */
+const API_EXECUTABLE_KINDS = ["ollama"];
+
+/** BYOK/API 백엔드 spec 문자열(/runtime 완성 후보의 API 절반). */
+const API_BACKEND_SPECS = ["anthropic", "openai", "google", "ollama", "upstage"];
+
+/** /runtime 이 받는 spec 전체: 네이티브 CLI kind + API 백엔드. */
+const RUNTIME_SPECS = [...NATIVE_CLI_KINDS, ...API_BACKEND_SPECS];
+
+/**
+ * 저장 계약(automation 등)이 허용하는 kind 전체 — CLI + 로컬/BYOK 실행 kind.
+ * 데스크탑 shared/runtime-kinds.ts 와 동형(터미널 표기: antigravity→agy, acp 미지원).
+ */
+const CONTRACT_RUNTIME_KINDS = [...CLI_KINDS, "byok", "ollama", "lmstudio", "mlx"];
+
+/** 저장 계약이 허용하는 LLM 백엔드 — 데스크탑 shared/runtime-backends.ts 와 동일 15종. */
+const CONTRACT_RUNTIME_BACKENDS = [
+  "anthropic", "openai", "google", "ollama", "lmstudio", "mlx", "upstage", "custom", "glm",
+  "kimi", "deepseek", "minimax", "xai", "openrouter", "cursor",
+];
+
+module.exports = {
+  RUNTIME_KIND_SPECS,
+  RUNTIME_BIN,
+  CLI_KINDS,
+  NATIVE_CLI_KINDS,
+  ACP_CLI_KINDS,
+  CAPTURE_CLI_KINDS,
+  CAPTURE_RUNTIME_BIN,
+  API_EXECUTABLE_KINDS,
+  API_BACKEND_SPECS,
+  RUNTIME_SPECS,
+  CONTRACT_RUNTIME_KINDS,
+  CONTRACT_RUNTIME_BACKENDS,
+};

package/engine/runtimes/resolve.cjs

@@ -6,17 +6,45 @@
  * 아무것도 없으면 no_runtime "정직 정지" — 키워드/저품질 폴백 금지(오너 결정).
  */
 const { RUNTIME_BIN, whichSync, listAvailableCliRuntimes, activeRuntimeRow } = require("./detect.cjs");
+const KINDS = require("./kinds.cjs");
 const path = require("node:path");
 
 // Session이 실제 드라이버를 갖춘 런타임만 실행 대상으로 삼는다.
 // CLI는 native-host, Ollama는 로컬 API loop를 쓴다. 다른 드라이버가 포팅되면
 // 해당 집합에 추가한다(조용한 오폭 방지).
-const CLI_EXECUTABLE_KINDS = new Set(["claude-code", "codex", "gemini", "agy"]);
-const API_EXECUTABLE_KINDS = new Set(["ollama"]);
-const EXECUTABLE_KINDS = new Set([
-  ...CLI_EXECUTABLE_KINDS,
-  ...API_EXECUTABLE_KINDS,
-]);
+//
+// kimi/grok/cursor 는 ACP 드라이버(runtimes/acp-driver.cjs → 벤더 코어의 공용 ACP 러너)로 돈다
+// (PRD 2026-08-15 T-2). 벤더 코어가 그 러너를 갖고 있을 때만 실행 대상에 든다 — 옛 코어면
+// 종전과 같은 "드라이버 없음" 정직 거부.
+// 집합의 원소는 정본(runtimes/kinds.cjs)에서 파생한다 — 여기서 다시 적지 않는다.
+const NATIVE_CLI_KINDS = new Set(KINDS.NATIVE_CLI_KINDS);
+const ACP_CLI_KINDS = new Set(KINDS.ACP_CLI_KINDS);
+const API_EXECUTABLE_KINDS = new Set(KINDS.API_EXECUTABLE_KINDS);
+
+function acpKindsAvailable() {
+  try {
+    const { acpDriverAvailability } = require("./acp-driver.cjs");
+    return acpDriverAvailability().ok ? ACP_CLI_KINDS : new Set();
+  } catch {
+    return new Set();
+  }
+}
+
+// 라이브 집합: 네이티브 4종 + (코어가 ACP 러너를 갖고 있으면) ACP 3종.
+const CLI_EXECUTABLE_KINDS = new Proxy(NATIVE_CLI_KINDS, {
+  get(target, prop) {
+    const live = new Set([...target, ...acpKindsAvailable()]);
+    const value = live[prop];
+    return typeof value === "function" ? value.bind(live) : value;
+  },
+});
+const EXECUTABLE_KINDS = new Proxy(NATIVE_CLI_KINDS, {
+  get(target, prop) {
+    const live = new Set([...target, ...acpKindsAvailable(), ...API_EXECUTABLE_KINDS]);
+    const value = live[prop];
+    return typeof value === "function" ? value.bind(live) : value;
+  },
+});
 
 function apiRuntime(kind, model, source) {
   if (!API_EXECUTABLE_KINDS.has(kind)) return null;
@@ -56,7 +84,10 @@ function resolveRuntime({ db, prefs, explicit }) {
     const bin = RUNTIME_BIN[explicit];
     if (!bin) throw new NoRuntimeError(`unknown runtime: ${explicit}`);
     if (!CLI_EXECUTABLE_KINDS.has(explicit)) {
-      throw new NoRuntimeError(`runtime '${explicit}' has no v2 streaming driver yet (available: ${[...EXECUTABLE_KINDS].join(", ")})`);
+      const acpHint = ACP_CLI_KINDS.has(explicit)
+        ? ` — its ACP driver needs the desktop core with electron/runtime/acp.js (npm run vendor:core / agentlas doctor)`
+        : "";
+      throw new NoRuntimeError(`runtime '${explicit}' has no v2 streaming driver yet (available: ${[...EXECUTABLE_KINDS].join(", ")})${acpHint}`);
     }
     const p = whichSync(bin);
     if (!p) throw new NoRuntimeError(`runtime '${explicit}' requested but '${bin}' is not on PATH`);
@@ -109,6 +140,8 @@ module.exports = {
   NoRuntimeError,
   EXECUTABLE_KINDS,
   CLI_EXECUTABLE_KINDS,
+  NATIVE_CLI_KINDS,
+  ACP_CLI_KINDS,
   API_EXECUTABLE_KINDS,
   sharedRuntimeKind,
 };

package/engine/ui/commands-catalog.cjs

@@ -107,6 +107,8 @@ const CATALOG = [
   { name: "import", group: "advanced", tier: "more", surfaces: BOTH, args: "<path>", argsKo: "<경로>", ko: "로컬 폴더 에이전트 가져오기", en: "Import a local folder agent" },
   { name: "cd", group: "advanced", tier: "more", surfaces: BOTH, args: "<agent>", argsKo: "<에이전트>", ko: "그 에이전트의 폴더 경로를 출력", en: "Print that agent's folder path" },
   { name: "native", group: "advanced", tier: "more", surfaces: BOTH, args: "prepare <agent>", argsKo: "prepare <에이전트>", ko: "네이티브 CLI 컨텍스트 생성", en: "Prepare native CLI context" },
+  // CLI only: stdout is the protocol wire, so it cannot run inside the REPL.
+  { name: "acp", group: "advanced", tier: "more", surfaces: CLI, args: "[--info]", ko: "에디터(Zed·JetBrains)용 ACP 에이전트로 실행", en: "Serve Agentlas as an ACP agent for editors (Zed, JetBrains)" },
   { name: "mcp", group: "advanced", tier: "more", surfaces: BOTH, args: "[list|probe <id>]", ko: "MCP 서버", en: "MCP servers" },
   { name: "plugin", group: "advanced", tier: "more", surfaces: BOTH, args: "<add <slug>|list|remove>", ko: "Hub 플러그인 (MCP 서버)", en: "Hub plugins (MCP servers)" },
   { name: "creds", group: "advanced", tier: "more", surfaces: BOTH, args: "<list|save|file>", ko: "API 키 보관 (값은 절대 표시 안 함)", en: "API keys (values are never printed)" },

package/engine/ui/palette.cjs

@@ -28,7 +28,8 @@ const SLASH_COMMANDS = catalog.forSurface("repl").map((entry) => ({
 }));
 
 const SLASH_NAMES = SLASH_COMMANDS.map((c) => c.command);
-const RUNTIME_KINDS = ["claude-code", "codex", "agy", "gemini"];
+// /runtime 완성 후보 — 정본(runtimes/kinds.cjs)의 네이티브 스폰 러너 4종.
+const RUNTIME_KINDS = require("../runtimes/kinds.cjs").NATIVE_CLI_KINDS;
 const EFFORT_LEVELS = ["none", "minimal", "low", "medium", "high", "xhigh", "max"];
 const PERM_LEVELS = ["read", "write", "full"];
 // 세션 인자를 받는 명령 — 완성 후보를 살아있는 세션 키(s1, s2…)로 채운다.

package/engine/ui/repl.cjs

@@ -791,7 +791,8 @@ function handleSlash(ctx, cmdline, api) {
        * (REPL의 평문 입력이 곧 run이다).
        */
       // help/agents/list/mcp/doctor 등은 위 케이스에서 이미 처리된다.
-      const REPL_EXCLUDED = new Set(["firm", "setup", "run"]);
+      // acp: stdout becomes the protocol wire — meaningless (and destructive) inside the REPL.
+      const REPL_EXCLUDED = new Set(["firm", "setup", "run", "acp"]);
       if (!REPL_EXCLUDED.has(cmd) && commands.COMMANDS[cmd]) {
         const result = commands.COMMANDS[cmd]().run(ctx, rest);
         if (result && typeof result.then === "function") {

package/engine/ui/shell.cjs

@@ -45,6 +45,35 @@ function loadRenderer() {
   }
 }
 
+/*
+ * 제어 블록 스트리퍼 — 정본은 벤더 코어의 shared/agent-control-blocks
+ * (Desktop·Mobile 과 같은 규칙: Memory Events/Delegate/Automation 헤딩,
+ * <<agentlas-ask>>·<<agentlas-surface>>·<<agentlas-one-followups>>·goal-complete
+ * 마커, 스트리밍 미완성 꼬리까지). 손 regex 는 Memory Events 만 알아 나머지
+ * 마커가 화면에 원문으로 샜다. 옛 벤더 번들이라 정본이 없으면 종전 regex 로
+ * fail-open — 스트리퍼 부재가 TUI 를 죽여선 안 된다.
+ */
+let _stripCanonical; // undefined=미시도 · null=정본 없음 · function=정본
+function stripControlBlocksForDisplay(text, streaming) {
+  if (_stripCanonical === undefined) {
+    try {
+      const loaded = require("../core/desktop-core.cjs").loadCoreShared("agent-control-blocks");
+      _stripCanonical = loaded && loaded.module && typeof loaded.module.stripAgentControlBlocks === "function"
+        ? loaded.module.stripAgentControlBlocks
+        : null;
+    } catch {
+      _stripCanonical = null;
+    }
+  }
+  const value = String(text);
+  if (_stripCanonical) {
+    try {
+      return _stripCanonical(value, { streaming: !!streaming });
+    } catch { /* 정본 실패 → 아래 종전 regex 로 fail-open */ }
+  }
+  return value.replace(/\n#{1,3} Memory Events\b[\s\S]*$/, "\n");
+}
+
 /* Ui 를 상속해 write 초크포인트만 렌더러로 돌린다. */
 class ShellUi extends Ui {
   /*
@@ -127,16 +156,22 @@ class ShellUi extends Ui {
     if (!this._md) this.streamStart();
     this._mdText += String(text);
     /*
-     * Memory Events 봉투는 런타임 계약(펜스 파이프라인이 수확)이지 사용자용이 아니다.
+     * 제어 블록은 런타임 계약(펜스 파이프라인이 수확)이지 사용자용이 아니다.
      * append-only 기본 REPL은 이미 찍힌 봉투를 지울 수 없지만, 누적 재렌더는
      * 표시만 잘라낼 수 있다 — 수확 경로(st.text/fences)는 건드리지 않는다.
+     * 정본 스트리퍼의 streaming 모드가 미완성 마커 꼬리도 한 프레임 감춘다.
      */
-    const visible = this._mdText.replace(/\n#{1,3} Memory Events\b[\s\S]*$/, "\n");
+    const visible = stripControlBlocksForDisplay(this._mdText, true);
     this._md.setText(visible);
     this._tui.requestRender();
     this._streaming = true;
   }
   streamEnd() {
+    // 확정 렌더 — streaming 모드가 감춰 두던 꼬리를 settled 규칙으로 최종 판정한다.
+    if (this._md && this._mdText) {
+      this._md.setText(stripControlBlocksForDisplay(this._mdText, false));
+      this._tui.requestRender();
+    }
     this._md = null;
     this._mdText = "";
     this._streaming = false;
@@ -615,4 +650,4 @@ async function startShell(ctx, opts = {}) {
   return new Promise(() => {});
 }
 
-module.exports = { startShell };
+module.exports = { startShell, stripControlBlocksForDisplay };

package/engine/vendor/desktop-core.manifest.json

@@ -1,7 +1,7 @@
 {
-  "version": "2",
-  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v2/desktop-core.tar.gz",
-  "sha256": "782760c34af1d06b9efd212d48ba032fe46907bdc8bc836025c44fc658968d6f",
-  "sizeBytes": 12295321,
-  "writtenAt": "2026-08-09T21:43:34.707Z"
+  "version": "3",
+  "url": "https://github.com/agentlas-ai/agentlas-terminal/releases/download/desktop-core-v3/desktop-core.tar.gz",
+  "sha256": "a72cce0ccfe718e2a9255b1b4722d330ef9887e22be92c654a0435f17f5ee178",
+  "sizeBytes": 12437404,
+  "writtenAt": "2026-08-18T04:09:04.540Z"
 }

package/engine/workforce/capture.cjs

@@ -24,14 +24,10 @@ const path = require("node:path");
 const { spawn } = require("node:child_process");
 const { dbPath, userDataDir } = require("../core/paths.cjs");
 
-// 캡처 드라이버가 검증된 런타임만. v2 detect.cjs의 RUNTIME_BIN에는 kimi/grok/cursor도
-// 있지만 buildArgs/텍스트 추출 계약이 없으므로 여기 목록에 절대 조용히 추가하지 않는다.
-const RUNTIME_BIN = {
-  "claude-code": "claude",
-  codex: "codex",
-  agy: "agy",
-  gemini: "gemini",
-};
+// 캡처 드라이버가 검증된 런타임만. 정본(runtimes/kinds.cjs)의 RUNTIME_BIN에는 kimi/grok/cursor도
+// 있지만 buildArgs/텍스트 추출 계약이 없으므로 캡처 검증 파생본만 쓴다 — 새 kind 를
+// 정본에 추가해도 capture:true 를 명시하기 전엔 여기 조용히 들어오지 않는다.
+const { CAPTURE_RUNTIME_BIN: RUNTIME_BIN } = require("../runtimes/kinds.cjs");
 
 const SERVICE = "com.agentlas.desktop";
 

package/engine/workforce/deps.cjs

@@ -523,6 +523,13 @@ function projectContextSlice(projectPath, task) {
         "--task-stdin",
         "--no-refresh",
         "--render",
+        // Recall degrades to a labelled map, never to nothing. Core's passive
+        // freshness check walks the whole repository (measured 11.0s on the
+        // pilot) against this 4s timeout, and any non-zero exit is swallowed
+        // into "" below — so without a budget a large project silently lost
+        // its slice on every turn.
+        "--allow-stale",
+        "--freshness-budget", "0.4",
       ],
       {
         cwd: projectPath,

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "agentlas",
-  "version": "1.0.47",
+  "version": "1.0.49",
   "description": "Agentlas project terminal — run project controllers and task-scoped agent teams from the terminal. Standalone: no desktop app process required.",
   "bin": {
     "agentlas": "bin/agentlas.cjs"
   },
   "scripts": {
+    "test": "sh test/smoke.sh",
     "smoke": "sh test/smoke.sh",
     "test:release-contracts": "npm run smoke",
     "sync:architecture": "node scripts/sync-architecture-from-desktop.cjs",