u-foo 3.0.0 → 3.0.2

package/src/code/runtime/taskRun.js

@@ -4,6 +4,15 @@ const { randomUUID } = require("crypto");
 
 /**
  * TaskRun registry — parent Task node identity vs runnable attempt.
+ *
+ * Scheduler owner: TaskLoop (`processTaskRun` / `resumePersistedTaskRuns`).
+ * Agent Loop may only issue control commands (start/cancel/complete) via CAS.
+ *
+ * Restart rules:
+ * - queued → remain queued (scheduler resumes)
+ * - running + phase waiting_model|executing_tools|planning → requeue to queued
+ * - cancelling → stay cancelling until cancel completes
+ * - terminal → never transition backward
  */
 
 const TASK_RUN_STATUSES = Object.freeze([
@@ -25,6 +34,31 @@ const TASK_RUN_PHASES = Object.freeze([
 
 const TERMINAL_TASK_RUN = new Set(["succeeded", "failed", "cancelled"]);
 
+/** Keep in sync with protocol/transitions.TASK_RUN_TRANSITIONS. */
+const TASK_RUN_TRANSITIONS = Object.freeze({
+  queued: Object.freeze(["running", "cancelled"]),
+  running: Object.freeze(["succeeded", "failed", "cancelling"]),
+  cancelling: Object.freeze(["cancelled", "failed"]),
+  succeeded: Object.freeze([]),
+  failed: Object.freeze([]),
+  cancelled: Object.freeze([]),
+});
+
+/** Default write-lease / heartbeat staleness (ms). */
+const DEFAULT_LEASE_STALE_MS = 30 * 60 * 1000;
+
+/** Extra recovery edge used only by recoverTaskRunsAfterRestart. */
+const RECOVERY_TRANSITIONS = Object.freeze({
+  running: Object.freeze(["queued"]),
+});
+
+function isAllowedTaskRunTransition(fromStatus = "", toStatus = "") {
+  const from = String(fromStatus || "").trim();
+  const to = String(toStatus || "").trim();
+  const allowed = TASK_RUN_TRANSITIONS[from];
+  if (!allowed) return false;
+  return allowed.includes(to);
+}
 function createTaskRunId() {
   return `trun_${Date.now().toString(36)}_${randomUUID().slice(0, 6)}`;
 }
@@ -33,6 +67,7 @@ function emptyTaskRunStore() {
   return {
     byId: {},
     commandLog: {},
+    wakeupLog: {},
   };
 }
 
@@ -47,6 +82,9 @@ function ensureTaskRunStore(executionState = null) {
   if (!state.taskRuns.commandLog || typeof state.taskRuns.commandLog !== "object") {
     state.taskRuns.commandLog = {};
   }
+  if (!state.taskRuns.wakeupLog || typeof state.taskRuns.wakeupLog !== "object") {
+    state.taskRuns.wakeupLog = {};
+  }
   return state.taskRuns;
 }
 
@@ -55,13 +93,22 @@ function createTaskRun({
   parentNodeId = "",
   childGraphId = "",
   attempt = 1,
+  kind = "",
+  objective = "",
+  title = "",
 } = {}) {
   const now = new Date().toISOString();
+  const parentNode = String(parentNodeId || "").trim();
+  const resolvedKind = String(kind || "").trim()
+    || (parentNode ? "graph_node" : "standalone");
   return {
     id: createTaskRunId(),
+    kind: resolvedKind,
     parentGraphId: String(parentGraphId || "").trim(),
-    parentNodeId: String(parentNodeId || "").trim(),
+    parentNodeId: parentNode,
     childGraphId: String(childGraphId || "").trim(),
+    objective: String(objective || "").trim(),
+    title: String(title || objective || "").trim(),
     status: "queued",
     phase: "initializing",
     attempt: Number.isFinite(attempt) ? Math.max(1, Math.floor(attempt)) : 1,
@@ -73,6 +120,8 @@ function createTaskRun({
     createdAt: now,
     startedAt: "",
     completedAt: "",
+    heartbeatAt: "",
+    lastWakeupId: "",
   };
 }
 
@@ -113,8 +162,26 @@ function isTerminalTaskRun(run = null) {
   return Boolean(run && TERMINAL_TASK_RUN.has(String(run.status || "")));
 }
 
+function touchTaskRunHeartbeat(executionState = null, taskRunId = "") {
+  const run = getTaskRun(executionState, taskRunId);
+  if (!run) return null;
+  run.heartbeatAt = new Date().toISOString();
+  putTaskRun(executionState, run);
+  return run;
+}
+
+function isTransitionAllowed(fromStatus, toStatus, { allowRecovery = false } = {}) {
+  if (fromStatus === toStatus) return true;
+  if (isAllowedTaskRunTransition(fromStatus, toStatus)) return true;
+  if (allowRecovery) {
+    const extra = RECOVERY_TRANSITIONS[fromStatus] || [];
+    return extra.includes(toStatus);
+  }
+  return false;
+}
+
 /**
- * Compare-and-set status transition. Returns { ok, run }.
+ * Compare-and-set status transition. Enforces allowed edges; terminal is final.
  */
 function casTaskRunStatus(executionState = null, taskRunId = "", {
   expectedStatus = "",
@@ -123,6 +190,7 @@ function casTaskRunStatus(executionState = null, taskRunId = "", {
   result = null,
   error = null,
   changedFiles = null,
+  allowRecovery = false,
 } = {}) {
   const run = getTaskRun(executionState, taskRunId);
   if (!run) return { ok: false, code: "TASK_RUN_NOT_FOUND", run: null };
@@ -135,10 +203,28 @@ function casTaskRunStatus(executionState = null, taskRunId = "", {
       currentStatus: run.status,
     };
   }
+  if (TERMINAL_TASK_RUN.has(run.status)) {
+    return {
+      ok: false,
+      code: "TASK_ALREADY_TERMINAL",
+      run,
+      currentStatus: run.status,
+    };
+  }
   const next = String(nextStatus || "").trim();
   if (!TASK_RUN_STATUSES.includes(next)) {
     return { ok: false, code: "INVALID_TASK_STATUS", run };
   }
+  if (!isTransitionAllowed(run.status, next, { allowRecovery })) {
+    return {
+      ok: false,
+      code: "TASK_TRANSITION_FORBIDDEN",
+      run,
+      currentStatus: run.status,
+      nextStatus: next,
+      allowed: (TASK_RUN_TRANSITIONS[run.status] || []).slice(),
+    };
+  }
   run.status = next;
   if (phase && TASK_RUN_PHASES.includes(phase)) run.phase = phase;
   if (result !== null) run.result = result;
@@ -150,6 +236,7 @@ function casTaskRunStatus(executionState = null, taskRunId = "", {
     run.phase = "finalizing";
   }
   if (next === "cancelling") run.cancelRequested = true;
+  run.heartbeatAt = new Date().toISOString();
   putTaskRun(executionState, run);
   return { ok: true, run };
 }
@@ -168,10 +255,89 @@ function getCachedControlCommand(executionState = null, commandId = "") {
   return store.commandLog[id] ? JSON.parse(JSON.stringify(store.commandLog[id])) : null;
 }
 
+/**
+ * Deduplicate wakeups by wakeupId. Second delivery returns cached result.
+ */
+function beginWakeup(executionState = null, wakeupId = "", meta = {}) {
+  const id = String(wakeupId || "").trim();
+  if (!id) return { ok: true, fresh: true };
+  const store = ensureTaskRunStore(executionState);
+  const existing = store.wakeupLog[id];
+  if (existing && existing.status === "completed") {
+    return {
+      ok: true,
+      fresh: false,
+      idempotentReplay: true,
+      result: existing.result ? JSON.parse(JSON.stringify(existing.result)) : existing,
+    };
+  }
+  if (existing && existing.status === "started") {
+    return {
+      ok: true,
+      fresh: false,
+      idempotentReplay: true,
+      result: { status: "in_flight", wakeupId: id },
+    };
+  }
+  store.wakeupLog[id] = {
+    status: "started",
+    startedAt: new Date().toISOString(),
+    ...meta,
+  };
+  return { ok: true, fresh: true };
+}
+
+function completeWakeup(executionState = null, wakeupId = "", result = {}) {
+  const id = String(wakeupId || "").trim();
+  if (!id) return;
+  const store = ensureTaskRunStore(executionState);
+  store.wakeupLog[id] = {
+    ...(store.wakeupLog[id] || {}),
+    status: "completed",
+    completedAt: new Date().toISOString(),
+    result: JSON.parse(JSON.stringify(result || {})),
+  };
+}
+
+/**
+ * After process restart: requeue interrupted running runs; leave cancelling alone.
+ * Does not execute tools — caller should invoke processTaskRun separately.
+ */
+function recoverTaskRunsAfterRestart(executionState = null) {
+  const store = ensureTaskRunStore(executionState);
+  const recovered = [];
+  for (const run of Object.values(store.byId)) {
+    if (!run) continue;
+    if (run.status === "running") {
+      const phase = String(run.phase || "");
+      if (phase === "waiting_model" || phase === "executing_tools" || phase === "planning") {
+        const cas = casTaskRunStatus(executionState, run.id, {
+          expectedStatus: "running",
+          nextStatus: "queued",
+          phase: "initializing",
+          allowRecovery: true,
+        });
+        recovered.push({
+          taskRunId: run.id,
+          action: cas.ok ? "requeued" : "skip",
+          code: cas.ok ? "" : cas.code,
+        });
+      } else {
+        recovered.push({ taskRunId: run.id, action: "resume_running" });
+      }
+    } else if (run.status === "queued" || run.status === "cancelling") {
+      recovered.push({ taskRunId: run.id, action: `resume_${run.status}` });
+    }
+  }
+  return recovered;
+}
+
 module.exports = {
   TASK_RUN_STATUSES,
   TASK_RUN_PHASES,
   TERMINAL_TASK_RUN,
+  TASK_RUN_TRANSITIONS,
+  DEFAULT_LEASE_STALE_MS,
   createTaskRunId,
   emptyTaskRunStore,
   ensureTaskRunStore,
@@ -181,7 +347,11 @@ module.exports = {
   findActiveTaskRunForNode,
   listActiveWritingTaskRuns,
   isTerminalTaskRun,
+  touchTaskRunHeartbeat,
   casTaskRunStatus,
   cacheControlCommand,
   getCachedControlCommand,
+  beginWakeup,
+  completeWakeup,
+  recoverTaskRunsAfterRestart,
 };

package/src/code/runtime/workspaceLease.js

@@ -190,6 +190,46 @@ function hasActiveWriteLease(executionState = null) {
   return countWriteLeases(executionState) > 0;
 }
 
+/**
+ * Release leases whose TaskRun is missing/terminal, or whose acquiredAt is older
+ * than maxAgeMs without an active non-terminal run heartbeat.
+ */
+function releaseStaleWriteLeases(executionState = null, {
+  maxAgeMs = require("./taskRun").DEFAULT_LEASE_STALE_MS,
+  nowMs = Date.now(),
+} = {}) {
+  const {
+    getTaskRun,
+    isTerminalTaskRun,
+  } = require("./taskRun");
+  const lease = ensureWorkspaceLease(executionState);
+  const holders = normalizeHolders(lease);
+  const released = [];
+  const kept = [];
+  const maxAge = Number.isFinite(maxAgeMs) ? Math.max(0, maxAgeMs) : 0;
+
+  for (const holder of holders) {
+    const run = getTaskRun(executionState, holder.taskRunId);
+    if (!run || isTerminalTaskRun(run)) {
+      released.push({ taskRunId: holder.taskRunId, reason: "terminal_or_missing" });
+      continue;
+    }
+    const acquired = Date.parse(String(holder.acquiredAt || ""));
+    if (maxAge > 0 && Number.isFinite(acquired) && (nowMs - acquired) > maxAge) {
+      const beat = Date.parse(String(run.heartbeatAt || run.startedAt || ""));
+      if (!Number.isFinite(beat) || (nowMs - beat) > maxAge) {
+        released.push({ taskRunId: holder.taskRunId, reason: "stale_heartbeat" });
+        continue;
+      }
+    }
+    kept.push(holder);
+  }
+
+  lease.holders = kept;
+  if (kept.length === 0) lease.acquiredAt = "";
+  return { ok: true, released, kept: kept.slice(), lease };
+}
+
 module.exports = {
   WRITE_TOOLS,
   MAX_CONCURRENT_WRITE_LEASES,
@@ -205,4 +245,5 @@ module.exports = {
   clearWorkspaceLease,
   checkWriteAllowed,
   hasActiveWriteLease,
+  releaseStaleWriteLeases,
 };

package/src/code/sessionStore.js

@@ -68,6 +68,7 @@ function normalizeContextPolicy(value = {}) {
 }
 
 function buildSessionSnapshot(input = {}) {
+  // Durable session fields vs projections: src/code/protocol/ownership.js
   const source = input && typeof input === "object" ? input : {};
   const sessionId = resolveSessionId(source.sessionId);
   const createdAt = String(source.createdAt || "").trim() || toIsoNow();

package/src/code/taskRoute.js

@@ -0,0 +1,73 @@
+"use strict";
+
+/**
+ * Structural / explicit decomposition upgrade decisions (R7).
+ * Not a language-specific bug-keyword classifier.
+ */
+
+function shouldUpgradeToDecomposition(task = "", options = {}) {
+  const text = String(task || "").trim();
+  const reasons = [];
+
+  if (options.forceDirect === true || options.disableDecomposition === true) {
+    return {
+      upgrade: false,
+      reason: "forced_direct",
+      reasons: ["forced_direct"],
+    };
+  }
+  if (options.forceDecomposition === true || options.forceDecompose === true) {
+    return {
+      upgrade: true,
+      reason: "forced_decomposition",
+      reasons: ["forced_decomposition"],
+    };
+  }
+  if (!text) {
+    return { upgrade: false, reason: "empty", reasons: ["empty"] };
+  }
+
+  // Explicit user/model requests (EN + ZH).
+  if (/(?:\bdecompos(?:e|ition)\b|\bbreak\s+(?:this|it)\s+down\b|\bmulti[- ]?step\s+plan\b|拆解|分步|分解任务|制定计划)/i.test(text)) {
+    reasons.push("explicit_decompose_request");
+  }
+
+  // Multiple independently verifiable goals (numbered / bulleted / conjunctions).
+  const numbered = (text.match(/(?:^|\n)\s*(?:\d+[\).]|[-*•])\s+\S+/g) || []).length;
+  if (numbered >= 2) reasons.push("multiple_listed_goals");
+
+  const multiClause = /(?:^|[;；。\n])\s*(?:and\s+also|also|然后|并且|同时|另外|以及)\b/i.test(text)
+    || (text.split(/[;；]/).map((s) => s.trim()).filter((s) => s.length > 12).length >= 3);
+  if (multiClause) reasons.push("multi_clause_objectives");
+
+  // High-risk / multi-file structural cues (not "fix" alone).
+  if (/\b(?:across\s+(?:files?|modules?|packages?)|multiple\s+files?|refactor\s+the\s+\w+|迁移|跨文件|多文件)\b/i.test(text)) {
+    reasons.push("multi_file_or_refactor_scope");
+  }
+  if (/\b(?:checkpoint|rollback|migration|schema\s+change|生产环境|回滚)\b/i.test(text)) {
+    reasons.push("high_risk_change");
+  }
+
+  // Runtime budget / prior failures may request upgrade.
+  if (Number(options.failureCount || 0) >= 2) {
+    reasons.push("repeated_failures");
+  }
+  if (options.modelRequestedUpgrade === true) {
+    reasons.push("model_route_decision");
+  }
+  if (options.hasPlanGraph === true) {
+    // Already structured — keep direct loop unless other reasons fire.
+    // (graph exists is not itself a decompose trigger)
+  }
+
+  const upgrade = reasons.length > 0;
+  return {
+    upgrade,
+    reason: upgrade ? reasons[0] : "direct_default",
+    reasons,
+  };
+}
+
+module.exports = {
+  shouldUpgradeToDecomposition,
+};

package/src/code/thinkingLevels.js

@@ -0,0 +1,132 @@
+"use strict";
+
+/**
+ * Ucode thinking-intensity levels.
+ *
+ * Used as the secondary `/model <id> <level>` menu after picking a model.
+ * Maps to Anthropic extended-thinking budget_tokens and OpenAI-compatible
+ * reasoning_effort where the transport supports it.
+ */
+
+const THINKING_LEVELS = Object.freeze([
+  {
+    id: "off",
+    desc: "disable extended thinking",
+    budgetTokens: 0,
+    reasoningEffort: "",
+  },
+  {
+    id: "low",
+    desc: "light thinking",
+    budgetTokens: 2048,
+    reasoningEffort: "low",
+  },
+  {
+    id: "medium",
+    desc: "default thinking",
+    budgetTokens: 10000,
+    reasoningEffort: "medium",
+  },
+  {
+    id: "high",
+    desc: "deeper thinking",
+    budgetTokens: 32000,
+    reasoningEffort: "high",
+  },
+  {
+    id: "max",
+    desc: "maximum thinking budget",
+    budgetTokens: 48000,
+    reasoningEffort: "high",
+  },
+]);
+
+const DEFAULT_THINKING_LEVEL = "medium";
+const THINKING_LEVEL_IDS = new Set(THINKING_LEVELS.map((item) => item.id));
+
+function normalizeThinkingLevel(value = "") {
+  const raw = String(value || "").trim().toLowerCase();
+  if (!raw) return "";
+  if (raw === "none" || raw === "disable" || raw === "disabled" || raw === "0") return "off";
+  if (raw === "med" || raw === "default") return "medium";
+  if (raw === "maximum" || raw === "xhigh" || raw === "ultra") return "max";
+  if (THINKING_LEVEL_IDS.has(raw)) return raw;
+  return "";
+}
+
+function getThinkingLevel(id = "") {
+  const normalized = normalizeThinkingLevel(id) || DEFAULT_THINKING_LEVEL;
+  return THINKING_LEVELS.find((item) => item.id === normalized) || THINKING_LEVELS[2];
+}
+
+function suggestThinkingLevels(options = {}) {
+  const current = normalizeThinkingLevel(options.current || "") || DEFAULT_THINKING_LEVEL;
+  return THINKING_LEVELS.map((item) => ({
+    id: item.id,
+    desc: item.id === current ? `${item.desc} · current` : item.desc,
+  }));
+}
+
+function resolveThinkingFromEnvAndConfig({
+  env = process.env,
+  configLevel = "",
+} = {}) {
+  // Explicit numeric budget still wins (advanced override).
+  const rawBudget = env && env.UFOO_UCODE_THINKING_BUDGET_TOKENS;
+  if (rawBudget !== undefined && rawBudget !== null && String(rawBudget).trim() !== "") {
+    const parsed = Number.parseInt(String(rawBudget), 10);
+    if (!Number.isFinite(parsed) || parsed <= 0) {
+      return {
+        level: "off",
+        budgetTokens: 0,
+        reasoningEffort: "",
+        source: "env-budget",
+      };
+    }
+    return {
+      level: "",
+      budgetTokens: Math.floor(parsed),
+      reasoningEffort: "",
+      source: "env-budget",
+    };
+  }
+
+  const fromEnv = normalizeThinkingLevel(env && env.UFOO_UCODE_THINKING);
+  const fromConfig = normalizeThinkingLevel(configLevel);
+  const level = fromEnv || fromConfig || DEFAULT_THINKING_LEVEL;
+  const spec = getThinkingLevel(level);
+  return {
+    level: spec.id,
+    budgetTokens: spec.budgetTokens,
+    reasoningEffort: spec.reasoningEffort,
+    source: fromEnv ? "env" : (fromConfig ? "config" : "default"),
+  };
+}
+
+function applyThinkingLevelToEnv(level = "", env = process.env) {
+  const normalized = normalizeThinkingLevel(level);
+  if (!normalized) return "";
+  const spec = getThinkingLevel(normalized);
+  try {
+    env.UFOO_UCODE_THINKING = spec.id;
+    if (spec.budgetTokens > 0) {
+      env.UFOO_UCODE_THINKING_BUDGET_TOKENS = String(spec.budgetTokens);
+    } else {
+      env.UFOO_UCODE_THINKING_BUDGET_TOKENS = "0";
+    }
+  } catch {
+    // ignore env write failures
+  }
+  return spec.id;
+}
+
+module.exports = {
+  THINKING_LEVELS,
+  THINKING_LEVEL_IDS,
+  DEFAULT_THINKING_LEVEL,
+  normalizeThinkingLevel,
+  getThinkingLevel,
+  suggestThinkingLevels,
+  resolveThinkingFromEnvAndConfig,
+  applyThinkingLevelToEnv,
+};

package/src/code/tools/taskRun.js

@@ -0,0 +1,118 @@
+"use strict";
+
+const {
+  startStandaloneTask,
+  cancelTask,
+  failTask,
+  completeTaskFromLoop,
+} = require("../runtime/taskControl");
+const { getTaskRun } = require("../runtime/taskRun");
+const { emptyExecutionState } = require("../context/executionSegment");
+
+function normalizeTaskRunCommand(args = {}) {
+  if (!args || typeof args !== "object") return null;
+  const operation = String(args.operation || args.op || "").trim().toLowerCase();
+  if (!operation) return null;
+  return {
+    operation,
+    objective: args.objective,
+    title: args.title,
+    taskRunId: args.taskRunId || args.task_run_id,
+    nodeId: args.nodeId || args.node_id,
+    reason: args.reason,
+    result: args.result,
+    commandId: args.commandId || args.command_id,
+  };
+}
+
+function runTaskRunTool(args = {}, options = {}) {
+  const command = normalizeTaskRunCommand(args) || args;
+  const operation = String(command.operation || "").trim().toLowerCase();
+  const executionState = options.executionState && typeof options.executionState === "object"
+    ? options.executionState
+    : emptyExecutionState();
+  const commandId = String(command.commandId || "").trim();
+  const runTool = options.runTool || null;
+  const knownTools = options.knownTools || null;
+
+  let payload;
+  if (operation === "start") {
+    payload = startStandaloneTask(executionState, {
+      objective: command.objective,
+      title: command.title,
+      commandId,
+      runTool,
+      knownTools,
+      processImmediately: options.processImmediately !== false,
+    });
+  } else if (operation === "cancel") {
+    payload = cancelTask(executionState, {
+      taskRunId: command.taskRunId,
+      nodeId: command.nodeId,
+      reason: command.reason,
+      commandId,
+    });
+  } else if (operation === "fail") {
+    payload = failTask(executionState, {
+      taskRunId: command.taskRunId,
+      nodeId: command.nodeId,
+      reason: command.reason,
+      commandId,
+    });
+  } else if (operation === "complete") {
+    payload = completeTaskFromLoop(executionState, {
+      taskRunId: command.taskRunId,
+      result: command.result,
+      commandId,
+    });
+  } else if (operation === "inspect") {
+    const run = getTaskRun(executionState, command.taskRunId);
+    if (!run) {
+      payload = {
+        status: "rejected",
+        ok: false,
+        errors: [{ code: "TASK_RUN_NOT_FOUND", message: "task run missing" }],
+      };
+    } else {
+      payload = {
+        status: "accepted",
+        ok: true,
+        taskRun: {
+          id: run.id,
+          kind: run.kind || "",
+          status: run.status,
+          phase: run.phase,
+          objective: run.objective || "",
+          title: run.title || "",
+          parentGraphId: run.parentGraphId || "",
+          parentNodeId: run.parentNodeId || "",
+          childGraphId: run.childGraphId || "",
+          result: run.result,
+          error: run.error,
+          changedFiles: Array.isArray(run.changedFiles) ? run.changedFiles.slice() : [],
+        },
+      };
+    }
+  } else {
+    payload = {
+      status: "rejected",
+      ok: false,
+      errors: [{
+        code: "UNKNOWN_TASK_RUN_OP",
+        message: `unknown task_run operation: ${operation || "(empty)"}`,
+      }],
+    };
+  }
+
+  const ok = payload && payload.ok !== false && payload.status !== "rejected";
+  return {
+    ok,
+    ...payload,
+    executionState,
+  };
+}
+
+module.exports = {
+  normalizeTaskRunCommand,
+  runTaskRunTool,
+};

package/src/config.js

@@ -2,7 +2,14 @@ const fs = require("fs");
 const os = require("os");
 const path = require("path");
 
-const UCODE_FIELDS = ["ucodeProvider", "ucodeModel", "ucodeBaseUrl", "ucodeApiKey", "ucodeAgentDir"];
+const UCODE_FIELDS = [
+  "ucodeProvider",
+  "ucodeModel",
+  "ucodeBaseUrl",
+  "ucodeApiKey",
+  "ucodeAgentDir",
+  "ucodeThinking",
+];
 
 const SETTINGS_MODEL_DEFAULTS = Object.freeze({
   agent: Object.freeze({
@@ -47,6 +54,7 @@ const DEFAULT_UCODE_CONFIG = {
   ucodeBaseUrl: "",
   ucodeApiKey: "",
   ucodeAgentDir: "",
+  ucodeThinking: "",
 };
 
 function normalizeLaunchMode(value) {
@@ -251,6 +259,7 @@ function loadGlobalUcodeConfig() {
     ucodeBaseUrl: typeof raw.ucodeBaseUrl === "string" ? raw.ucodeBaseUrl : "",
     ucodeApiKey: typeof raw.ucodeApiKey === "string" ? raw.ucodeApiKey : "",
     ucodeAgentDir: typeof raw.ucodeAgentDir === "string" ? raw.ucodeAgentDir : "",
+    ucodeThinking: typeof raw.ucodeThinking === "string" ? raw.ucodeThinking : "",
   };
 }