agentlas 0.6.0 → 0.9.1

package/engine/agentlas-repl.cjs

@@ -8,6 +8,7 @@
  * First launch runs an onboarding wizard (language → runtime → permission), stored in prefs.
  */
 const readline = require("node:readline");
+const crypto = require("node:crypto");
 const { Ui } = require("./agentlas-ui.cjs");
 const banner = require("./agentlas-banner.cjs");
 const { runNativeTurn } = require("./agentlas-native-host.cjs");
@@ -24,6 +25,12 @@ function runtimeLabel(rt) {
   return `${rt.backend}${rt.model ? " · " + rt.model : ""}`;
 }
 
+function runtimePromptForSession(prompt, ctx, rt, session, helpers) {
+  const resumesServerSide = rt && (rt.kind === "claude-code" || rt.kind === "codex");
+  if (!session?.id || !resumesServerSide || typeof helpers?.memoryEmitterPrompt !== "function") return prompt;
+  return `${prompt}\n\n${helpers.memoryEmitterPrompt(prompt, ctx)}`;
+}
+
 function normalizeLang(value) {
   const v = String(value || "").toLowerCase();
   return v === "en" || v === "ko" ? v : null;
@@ -162,7 +169,7 @@ function makeStyleGuard(ui) {
 function startRepl(opts) {
   const { db } = opts;
   const H = opts.helpers;
-  const prefs = opts.prefs || {};
+  const prefs = applyPreferenceDefaults(opts.prefs || {});
   prefs.agentRuntime = prefs.agentRuntime || {}; // { agentSlug|firmSlug: runtimeSpec|"auto" }
   let baseRuntime = opts.runtime; // session default; per-agent runtime auto-routes from this
   const ui = new Ui({ lang: terminalLang(prefs, opts) });
@@ -176,6 +183,8 @@ function startRepl(opts) {
     projectPath: opts.projectPath || null,
     routePreambleOnce: null,
     effort: prefs.effort || null, // /effort: low|medium|high|max → 런타임별 reasoning 강도
+    modelPinned: false, // true only after an explicit /model <id>; /model auto clears it
+    effortPinned: prefs.effortPinned === true || Boolean(prefs.effort), // /effort auto is the only automatic mode
     cost: {}, // runtimeLabel → { turns, in, out, cost, ms } — session usage ledger
   };
 
@@ -298,6 +307,16 @@ function startRepl(opts) {
     busy = true;
     currentAbort = new AbortController();
     const signal = currentAbort.signal;
+    let experienceRunId = `terminal-run:${crypto.randomUUID()}`;
+    const runStartedAt = Date.now();
+    let experienceFinalized = false;
+    let experienceContext = null;
+    let memorySettled = false;
+    let memoryContext = null;
+    let memoryRuntime = null;
+    let memoryModel = null;
+    let memoryOutput = "";
+    let memoryOutcome = "failed";
     try {
       ui.beginTurn({
         ...composerMeta(),
@@ -308,11 +327,67 @@ function startRepl(opts) {
           ui.warn(ui.t("interrupted"));
         },
       }); // 작업 중에도 composer/status bar와 실제 runtime task 목록을 화면 하단에 유지
+      if (H.ensureProjectForExecution) {
+        state.projectPath = H.ensureProjectForExecution(
+          db,
+          state.cwd,
+          state.permission,
+          "terminal-interactive-turn",
+        );
+      }
       const recordHistoryEntry = !runOptions.side;
       const targetLang = H.detectResponseLanguage ? H.detectResponseLanguage(prompt, ui.lang) : ui.lang;
-      const ctx = { ...ctxNow(), lang: targetLang, uiLang: ui.lang };
+      const curatedMemories = [];
       const rt = state.runtime;
-      const costLabel = runtimeLabel(rt);
+      const priorContextDigest = crypto.createHash("sha256")
+        .update(JSON.stringify(state.history.map((item) => ({ role: item.role, text: item.text }))))
+        .digest("hex");
+      const memoryTurn = typeof H.beginMemoryTurn === "function"
+        ? H.beginMemoryTurn(db, prompt, {
+            ...ctxNow(),
+            surface: runOptions.side ? "terminal-side-turn" : "terminal-interactive-turn",
+            conversationRef: rt.mode === "cli" ? state.native[rt.kind]?.id : null,
+            priorContextDigest,
+            // Provider session resume is conversation context, not turn
+            // identity. Every submitted host turn receives a fresh id.
+            stableTurnId: `terminal-turn:${crypto.randomUUID()}`,
+          })
+        : null;
+      if (memoryTurn?.turnId) experienceRunId = `terminal-run:${memoryTurn.turnId}`;
+      const ctx = {
+        ...ctxNow(),
+        lang: targetLang,
+        uiLang: ui.lang,
+        curatedMemories,
+        memoryTurn,
+        turnId: memoryTurn?.turnId || null,
+      };
+      memoryContext = ctx;
+      memoryRuntime = rt;
+      let workloadResolution = null;
+      if (state.subject && state.subject.kind === "firm" && typeof H.allocateWorkload === "function") {
+        ui.status(targetLang === "ko" ? "상위 AI가 팀 작업의 모델 비용을 배정 중…" : "Higher-level AI is allocating the team model…");
+        const planned = await H.allocateWorkload(db, prompt, {
+          runtime: rt,
+          cwd: state.cwd,
+          projectPath: state.projectPath,
+          agentId: state.subject.id,
+          lang: targetLang,
+          mode: "team",
+          modelPin: state.modelPinned ? rt.model : null,
+          effortPin: state.effortPinned ? (state.effort || "none") : undefined,
+          onWarning: (message) => ui.warn(message),
+        });
+        workloadResolution = planned && planned.resolution;
+        if (workloadResolution && workloadResolution.fallbackReason) {
+          ui.info(`model route: ${workloadResolution.source} · ${workloadResolution.model || runtimeLabel(rt)} · ${workloadResolution.fallbackReason}`);
+        }
+      }
+      const selectedModel = (workloadResolution && workloadResolution.model) || rt.model || null;
+      memoryModel = selectedModel;
+      const selectedEffort = workloadResolution ? workloadResolution.effort : state.effort || null;
+      const costLabel = selectedModel ? `${runtimeLabel(rt)} · ${selectedModel}` : runtimeLabel(rt);
+      experienceContext = { ctx, rt, selectedModel, curatedMemories, targetLang };
       const runEnv = H.buildChildEnv ? await H.buildChildEnv(db, { ...ctx, cwd: state.cwd }) : process.env;
       ui._lastUsage = null;
       const assistantUi = makeStyleGuard(ui);
@@ -325,35 +400,87 @@ function startRepl(opts) {
           ? `${state.routePreambleOnce}\n\n${state.subject.system}`
           : state.subject.system;
         state.routePreambleOnce = null;
-        const sys = H.augmentSystem(db, subjectSystem, ctx, false);
+        const sys = H.augmentSystem(db, subjectSystem, ctx, true, prompt);
+        // claude(--resume)·codex(resume <thread_id>)만 서버측에서 대화를 이어받아 이전 턴의
+        // 시스템 프롬프트를 유지한다(native-host.cjs claudeArgs/codexArgs). gemini CLI는 resume
+        // 플래그가 없어 매 턴이 새 프로세스 — session.id로 시스템 프롬프트를 비우면 2턴째부터
+        // 페르소나가 통째로 사라진다. 그래서 gemini는 매 턴 시스템 프롬프트를 다시 보낸다.
+        const resumesServerSide = rt.kind === "claude-code" || rt.kind === "codex";
+        // Claude/Codex resume keeps the first turn's system prompt. Append the
+        // current host contract to this turn's user payload so a resumed model
+        // cannot reuse a stale Memory Ticket id from an earlier turn.
+        const runtimePrompt = runtimePromptForSession(prompt, ctx, rt, session, H);
+        const memoryGuard = makeMemoryGuard(assistantUi, H.eventsHeading());
+        const connectedMcpServers = state.permission === "full" && H.mcpServers
+          ? H.mcpServers(db).filter((server) =>
+            server.enabled && server.transport === "stdio" && server.runtimeEligible === true && server.runtimeConsented === true)
+          : [];
         const res = await runNativeTurn({
           kind: rt.kind,
           bin,
-          prompt,
-          systemPrompt: session.id ? "" : sys,
+          prompt: runtimePrompt,
+          systemPrompt: session.id && resumesServerSide ? "" : sys,
           cwd: state.cwd,
           permission: state.permission,
           session,
-          model: rt.model || null, // /model (claude --model, codex -m, gemini -m)
-          effort: state.effort || null, // /effort (codex reasoning effort, claude think-keyword)
-          mcpServers:
-            state.permission === "full" && H.mcpServers
-              ? H.mcpServers(db).filter((s) => s.enabled && s.transport === "stdio")
-              : [],
+          model: selectedModel, // explicit /model pin or higher-level AI allocation
+          effort: selectedEffort, // explicit /effort pin or higher-level AI allocation
+          mcpServers: connectedMcpServers,
           env: runEnv,
-          ui: assistantUi,
+          ui: memoryGuard,
           signal,
         });
-        const at = (res.text || "").trim();
+        memoryOutput = String(res.text || "");
+        memoryOutcome = res.error ? "failed" : "succeeded";
+        let at = "";
+        let memoryResult = null;
+        if (typeof H.completeMemoryTurn === "function") {
+          try {
+            memoryResult = await H.completeMemoryTurn(db, memoryOutput, ctx, rt, {
+              model: selectedModel,
+              outcome: memoryOutcome,
+              requestText: prompt,
+              invokeCurator: !res.error,
+            });
+            memorySettled = true;
+          } catch {
+            // finally retries once without semantic Curator authority.
+          }
+          for (const memory of memoryResult?.curatedMemories || []) {
+            if (memory && !curatedMemories.some((item) => item.id === memory.id)) curatedMemories.push(memory);
+          }
+          at = (H.sanitizeAssistantText(memoryResult?.cleaned ?? memoryOutput) || "").trim();
+        } else {
+          at = (H.sanitizeAssistantText(res.text || "") || "").trim();
+        }
         if (recordHistoryEntry && at && !res.error) state.history.push({ role: "user", text: prompt }, { role: "assistant", text: at });
         recordCost(costLabel, res.usage);
         if (!runOptions.side && session.id && !res.error) persistSession(rt.kind, session.id, prompt);
+        if (typeof H.finalizeExperienceRun === "function") {
+          H.finalizeExperienceRun(db, {
+            agentId: ctx.agentId,
+            projectPath: ctx.projectPath,
+            cwd: state.cwd,
+            runtime: rt,
+            permission: state.permission,
+            model: selectedModel,
+            mcpServers: connectedMcpServers,
+            curatedMemories,
+            taskHint: prompt,
+            outcome: { status: res.error ? "failed" : "succeeded", failureCode: res.error ? "runtime-error" : null },
+            usage: res.usage,
+            durationMs: Date.now() - runStartedAt,
+            runId: experienceRunId,
+            lang: targetLang,
+          });
+          experienceFinalized = true;
+        }
       } else {
         const subjectSystem = state.routePreambleOnce
           ? `${state.routePreambleOnce}\n\n${state.subject.system}`
           : state.subject.system;
         state.routePreambleOnce = null;
-        const sys = H.augmentSystem(db, subjectSystem, ctx, true);
+        const sys = H.augmentSystem(db, subjectSystem, ctx, true, prompt);
         let apiKey = null;
         if (rt.backend !== "ollama") {
           apiKey = await H.apiKey(rt.backend);
@@ -369,7 +496,7 @@ function startRepl(opts) {
         const guard = makeMemoryGuard(assistantUi, H.eventsHeading());
         const res = await runApiTurn({
           backend: rt.backend,
-          model: rt.model || H.defaultApiModel(rt.backend),
+          model: selectedModel || H.defaultApiModel(rt.backend),
           apiKey,
           system: sys,
           messages,
@@ -377,12 +504,69 @@ function startRepl(opts) {
           ui: guard,
           signal,
         });
-        const cleaned = (H.curateCliReply(db, res.text || "", ctx) || "").trim();
+        memoryOutput = String(res.text || "");
+        memoryOutcome = "succeeded";
+        let cleaned = "";
+        if (typeof H.completeMemoryTurn === "function") {
+          let memoryResult = null;
+          try {
+            memoryResult = await H.completeMemoryTurn(db, memoryOutput, ctx, rt, {
+              model: selectedModel,
+              outcome: memoryOutcome,
+              requestText: prompt,
+            });
+            memorySettled = true;
+          } catch {
+            // finally retries once without semantic Curator authority.
+          }
+          for (const memory of memoryResult?.curatedMemories || []) {
+            if (memory && !curatedMemories.some((item) => item.id === memory.id)) curatedMemories.push(memory);
+          }
+          cleaned = (H.sanitizeAssistantText(memoryResult?.cleaned ?? memoryOutput) || "").trim();
+        } else {
+          cleaned = (H.sanitizeAssistantText(res.text || "") || "").trim();
+        }
         if (recordHistoryEntry && cleaned) state.history.push({ role: "user", text: prompt }, { role: "assistant", text: cleaned });
         recordCost(costLabel, ui._lastUsage);
+        if (typeof H.finalizeExperienceRun === "function") {
+          H.finalizeExperienceRun(db, {
+            agentId: ctx.agentId,
+            projectPath: ctx.projectPath,
+            cwd: state.cwd,
+            runtime: rt,
+            permission: state.permission,
+            model: selectedModel,
+            curatedMemories,
+            taskHint: prompt,
+            outcome: { status: "succeeded", failureCode: null },
+            usage: ui._lastUsage,
+            durationMs: Date.now() - runStartedAt,
+            runId: experienceRunId,
+            lang: targetLang,
+          });
+          experienceFinalized = true;
+        }
       }
     } catch (e) {
       ui.stopSpinner();
+      memoryOutcome = signal.aborted ? "cancelled" : "failed";
+      if (!experienceFinalized && experienceContext && typeof H.finalizeExperienceRun === "function") {
+        H.finalizeExperienceRun(db, {
+          agentId: experienceContext.ctx.agentId,
+          projectPath: experienceContext.ctx.projectPath,
+          cwd: state.cwd,
+          runtime: experienceContext.rt,
+          permission: experienceContext.ctx.permission,
+          model: experienceContext.selectedModel,
+          curatedMemories: experienceContext.curatedMemories,
+          taskHint: prompt,
+          outcome: { status: signal.aborted ? "cancelled" : "failed", failureCode: signal.aborted ? "operator-cancelled" : "runtime-error" },
+          durationMs: Date.now() - runStartedAt,
+          runId: experienceRunId,
+          lang: experienceContext.targetLang,
+        });
+        experienceFinalized = true;
+      }
       if (signal.aborted) {
         // user Ctrl-C — SIGINT handler already printed
       } else if (e && e.name === "AbortError") {
@@ -391,6 +575,21 @@ function startRepl(opts) {
         ui.error((e && e.message) || String(e));
       }
     } finally {
+      if (!memorySettled && memoryContext?.turnId && typeof H.completeMemoryTurn === "function") {
+        try {
+          await H.completeMemoryTurn(db, memoryOutput, memoryContext, memoryRuntime, {
+            model: memoryModel,
+            outcome: memoryOutcome,
+            requestText: prompt,
+            invokeCurator: false,
+          });
+          memorySettled = true;
+        } catch {
+          ui.warn(memoryContext.lang === "ko"
+            ? "메모리 영수증을 저장하지 못했습니다. 응답 실행은 유지됩니다."
+            : "The memory receipt could not be persisted; the response run is preserved.");
+        }
+      }
       busy = false;
       ui.endTurn();
       currentAbort = null;
@@ -407,6 +606,7 @@ function startRepl(opts) {
       const bin = H.which(H.RUNTIME_BIN[a]);
       if (!bin) return ui.error(ui.t("runtimeNotInstalled", a));
       state.runtime = { mode: "cli", kind: a };
+      state.modelPinned = false;
       baseRuntime = state.runtime; // 명시적 /runtime 은 세션 기본으로 고정 (이후 auto-route가 덮어쓰지 않게)
       state.native = {};
       return ui.ok(ui.t("runtimeSet", a));
@@ -416,6 +616,7 @@ function startRepl(opts) {
         a === "ollama"
           ? { mode: "api", backend: "ollama", model: state.runtime.backend === "ollama" ? state.runtime.model : null }
           : { mode: "api", backend: a, model: null };
+      state.modelPinned = false;
       baseRuntime = state.runtime; // 명시적 /runtime 은 세션 기본으로 고정
       return ui.ok(ui.t("runtimeSet", runtimeLabel(state.runtime)));
     }
@@ -438,6 +639,7 @@ function startRepl(opts) {
     if (pinned && pinned !== "auto") spec = pinned;
     else spec = caps.autoRuntimeFor(subject.capAgent, { installedKinds: installedKinds(), activeSpec: caps.specOf(baseRuntime) });
     state.runtime = caps.runtimeFromSpec(spec);
+    state.modelPinned = false;
     state.native = {};
   }
   // Tell the user when we routed to an image-capable runtime, or when the current one can't make images.
@@ -492,7 +694,7 @@ function startRepl(opts) {
       slug: firm.slug,
       label: displayName(firm) + " CEO",
       system: sys,
-      capAgent: { name: firm.name, name_en: firm.name_en || firm.name, tagline: firm.tagline, system_prompt: sys },
+      capAgent: { name: firm.name, name_en: firm.name_en || firm.name, tagline: firm.tagline, tagline_en: firm.tagline_en, entity_kind: "team", system_prompt: sys },
     };
     state.history = [];
     state.routePreambleOnce = null;
@@ -772,13 +974,33 @@ function startRepl(opts) {
           research = true;
           goal = goal.replace(/\s?--research(-evidence)?\b/g, "").trim();
         }
-        await H.stormRun(db, goal, { ui, cwd: state.cwd, research });
+        if (H.ensureProjectForExecution) {
+          state.projectPath = H.ensureProjectForExecution(db, state.cwd, state.permission, "terminal-storm");
+        }
+        await H.stormRun(db, goal, {
+          ui,
+          cwd: state.cwd,
+          permission: state.permission,
+          projectPath: state.projectPath,
+          research,
+        });
         return true;
       }
       case "build": {
         if (!arg) return ui.warn("usage: /build <만들고 싶은 에이전트/팀 설명>"), true;
         ui.line("");
-        await H.hepRun(["hep-build", arg], { cwd: state.cwd });
+        if (typeof H.terminalBuild !== "function") throw new Error("Terminal MCP build preflight is unavailable");
+        if (H.ensureProjectForExecution) {
+          state.projectPath = H.ensureProjectForExecution(db, state.cwd, state.permission, "terminal-build");
+        }
+        await H.terminalBuild(db, arg, {
+          cwd: state.cwd,
+          modelPin: state.modelPinned ? state.runtime.model : null,
+          effortPin: state.effortPinned ? (state.effort || "none") : undefined,
+          input: process.stdin,
+          promptOutput: process.stderr,
+          out: (line) => ui.line(String(line)),
+        });
         return true;
       }
       case "route": {
@@ -799,17 +1021,38 @@ function startRepl(opts) {
         else await H.hepRun(["hep-search", arg], { cwd: state.cwd });
         return true;
       }
-      case "install": {
-        if (!arg) return ui.warn("usage: /install <slug>  (/search 로 먼저 찾으세요)"), true;
-        if (H.cloudInstall) {
-          try { const r = await H.cloudInstall(db, arg.trim()); ui.ok((r && r.name) ? `설치됨: ${r.name}` : `설치됨: ${arg.trim()}`); }
-          catch (e) { ui.error((e && e.message) || String(e)); }
-        } else ui.warn("설치 기능을 사용할 수 없습니다.");
-        return true;
-      }
+      case "workforce":
       case "network":
       case "taskforce": {
-        if (!arg) return ui.warn("usage: /network <요청>  (A2A 태스크포스)"), true;
+        if (!arg) return ui.warn("usage: /network <요청> [--benchmark]  (Agent Workforce Ontology)"), true;
+        let goal = arg;
+        const benchmark = /(?:^|\s)--benchmark(?:\s|$)/.test(goal);
+        goal = goal.replace(/(?:^|\s)--benchmark(?=\s|$)/g, " ").trim();
+        let concurrency;
+        const parallel = goal.match(/(?:^|\s)--parallel\s+(\d+)\b/);
+        if (parallel) {
+          concurrency = Number(parallel[1]);
+          goal = goal.replace(parallel[0], "").trim();
+        }
+        if (H.ensureProjectForExecution) {
+          state.projectPath = H.ensureProjectForExecution(db, state.cwd, state.permission, "terminal-workforce");
+        }
+        ui.line("");
+        await H.workforceRun(db, goal, {
+          ui,
+          cwd: state.cwd,
+          permission: state.permission,
+          runtime: state.runtime,
+          projectPath: state.projectPath,
+          modelPin: state.modelPinned ? state.runtime.model : null,
+          effortPin: state.effortPinned ? (state.effort || "none") : undefined,
+          concurrency,
+          benchmark,
+        });
+        return true;
+      }
+      case "legacy-network": {
+        if (!arg) return ui.warn("usage: /legacy-network <요청>"), true;
         ui.line("");
         await H.hepRun(["hep-network", arg, "--project", state.cwd, "--runtime", "terminal"], { cwd: state.cwd });
         return true;
@@ -833,6 +1076,9 @@ function startRepl(opts) {
           concurrency = Number(m[1]);
           goal = goal.replace(m[0], "").trim();
         }
+        if (H.ensureProjectForExecution) {
+          state.projectPath = H.ensureProjectForExecution(db, state.cwd, state.permission, "terminal-swarm");
+        }
         await H.swarmRun(db, goal, {
           ui,
           cwd: state.cwd,
@@ -841,27 +1087,36 @@ function startRepl(opts) {
           concurrency,
           agent: state.subject && state.subject.capAgent,
           projectPath: state.projectPath,
+          modelPin: state.modelPinned ? state.runtime.model : null,
+          effortPin: state.effortPinned ? (state.effort || "none") : undefined,
         });
         return true;
       }
-      case "model":
+      case "model": {
         // CLI(claude/codex/gemini)와 BYOK/Ollama 모두 지원 — 각 런타임의 모델 플래그로 전달.
-        state.runtime.model = arg || null;
+        const requested = (arg || "").trim();
+        state.runtime.model = !requested || requested.toLowerCase() === "auto" ? null : requested;
+        state.modelPinned = Boolean(state.runtime.model);
         state.native = {}; // 새 모델로 세션 리셋
-        ui.ok(ui.t("modelSet", state.runtime.model || ui.t("modelDefault")));
+        ui.ok(ui.t("modelSet", state.runtime.model || "auto"));
         return true;
+      }
       case "effort": {
         const lv = (arg || "").toLowerCase().trim();
         if (!lv) {
-          ui.info(ui.t("effortCurrent", state.effort || ui.t("modelDefault")));
+          ui.info(ui.t("effortCurrent", state.effortPinned ? (state.effort || "off") : "auto"));
           return true;
         }
         if (!["low", "medium", "high", "max", "auto", "off"].includes(lv)) {
           return ui.warn(ui.t("effortUsage")), true;
         }
         state.effort = lv === "auto" || lv === "off" ? null : lv;
+        state.effortPinned = lv !== "auto";
+        prefs.effort = state.effort;
+        prefs.effortPinned = state.effortPinned;
+        if (opts.savePrefs) opts.savePrefs(prefs);
         state.native = {};
-        ui.ok(ui.t("effortSet", state.effort || ui.t("modelDefault")));
+        ui.ok(ui.t("effortSet", state.effortPinned ? (state.effort || "off") : "auto"));
         return true;
       }
       case "permission":
@@ -982,16 +1237,15 @@ function startRepl(opts) {
         const servers = H.mcpServers ? H.mcpServers(db) : [];
         ui.line("");
         ui.rule("MCP");
-        ui.line("   " + ui.c.emerald(ui.t("mcp.playwright").padEnd(22)) + ui.c.blue("stdio  ") + ui.c.green("on ") + ui.c.dim("  " + ui.t("mcp.fullOnly")));
         for (const s of servers) {
           let envKeys = [];
           try { envKeys = JSON.parse(s.env_keys_json || "[]"); } catch { /* ignore */ }
           const name = ui.lang === "en" ? (s.name_en || s.name) : s.name;
-          const on = s.enabled ? ui.c.green("on ") : ui.c.faint("off");
+          const on = s.enabled && s.runtimeConsented ? ui.c.green("on ") : s.enabled ? ui.c.faint("consent") : ui.c.faint("off");
           const envStr = envKeys.length ? envKeys.join(", ") : "no key";
           ui.line("   " + ui.c.emerald(String(name).padEnd(22)) + ui.c.blue(String(s.transport || "").padEnd(7)) + on + ui.c.dim("  " + envStr));
         }
-        const wired = servers.filter((s) => s.enabled && s.transport === "stdio").length + 1; // +1 = full-only Playwright
+        const wired = servers.filter((s) => s.enabled && s.transport === "stdio" && s.runtimeEligible === true && s.runtimeConsented === true).length;
         ui.line("   " + ui.c.faint(ui.t("mcp.wired", String(wired))));
         ui.line("   " + ui.c.faint(ui.t("mcp.usage")));
         return true;
@@ -1026,11 +1280,16 @@ function startRepl(opts) {
         } else {
           return ui.error(ui.t("noAgent", s.agentSlug)), true;
         }
-        if (s.kind && H.RUNTIME_BIN[s.kind] && H.which(H.RUNTIME_BIN[s.kind])) {
+        // 저장된 CLI 런타임이 실제로 설치돼 있을 때만 그 세션을 복원한다. s.kind가 없거나
+        // (손상된 resume 레코드) 런타임이 미설치면, 잘못된/"undefined" 키로 native 맵을
+        // 덮어써 현재 세션을 잃는 것을 막고 새 대화로 시작한다.
+        if (s.kind && s.sessionId && H.RUNTIME_BIN[s.kind] && H.which(H.RUNTIME_BIN[s.kind])) {
           state.runtime = { mode: "cli", kind: s.kind };
           baseRuntime = state.runtime;
+          state.native = { [s.kind]: { id: s.sessionId } };
+        } else {
+          state.native = {};
         }
-        state.native = { [s.kind]: { id: s.sessionId } };
         try {
           const fs2 = require("node:fs");
           if (s.cwd && fs2.existsSync(s.cwd)) state.cwd = s.cwd;
@@ -1213,17 +1472,29 @@ function startRepl(opts) {
           }
         }
       }
-      // 자동 엔진 개입은 명시적 opt-in 전용 (/config, 기본 off): direct 판정 + 실작업형 프롬프트일 때만.
+      // Workforce is the default for direct, goal-like work. An explicit
+      // `/config network off` remains a durable opt-out; Storm stays opt-in.
       if (state.subject && state.subject.kind === "direct" && goalLikePrompt(t)) {
         if (prefs.autoStorm && H.stormRun) {
           ui.info(ui.t("config.autoEngage", "stormbreaker", "storm"));
           await H.stormRun(db, t, { ui, cwd: state.cwd, research: false });
           return;
         }
-        if (prefs.autoNetwork && H.hepRun) {
-          ui.info(ui.t("config.autoEngage", "hep-network", "network"));
+        if (prefs.autoNetwork && H.workforceRun) {
+          ui.info(ui.t("config.autoEngage", "workforce ontology", "network"));
+          if (H.ensureProjectForExecution) {
+            state.projectPath = H.ensureProjectForExecution(db, state.cwd, state.permission, "terminal-workforce-auto");
+          }
           ui.line("");
-          await H.hepRun(["hep-network", t, "--project", state.cwd, "--runtime", "terminal"], { cwd: state.cwd });
+          await H.workforceRun(db, t, {
+            ui,
+            cwd: state.cwd,
+            permission: state.permission,
+            runtime: state.runtime,
+            projectPath: state.projectPath,
+            modelPin: state.modelPinned ? state.runtime.model : null,
+            effortPin: state.effortPinned ? (state.effort || "none") : undefined,
+          });
           return;
         }
       }
@@ -1400,6 +1671,11 @@ function startRepl(opts) {
   bootstrap();
 }
 
+function applyPreferenceDefaults(prefs) {
+  if (!Object.prototype.hasOwnProperty.call(prefs, "autoNetwork")) prefs.autoNetwork = true;
+  return prefs;
+}
+
 function printHelp(ui) {
   const c = ui.c;
   ui.line("");
@@ -1472,4 +1748,11 @@ function printKeybindings(ui) {
   for (const [k, v] of tips) ui.line("  " + c.emerald(k.padEnd(24)) + c.dim(v));
 }
 
-module.exports = { startRepl, runtimeLabel, makeMemoryGuard, makeStyleGuard };
+module.exports = {
+  startRepl,
+  runtimeLabel,
+  runtimePromptForSession,
+  makeMemoryGuard,
+  makeStyleGuard,
+  applyPreferenceDefaults,
+};