u-foo 3.0.1 → 3.0.3

package/src/code/providers/openaiChatTransport.js

@@ -2,6 +2,12 @@
 
 const { randomUUID } = require("crypto");
 const { assertTransport } = require("./transportContract");
+const {
+  extractVisionPayload,
+  stripVisionBase64,
+  visionSummaryText,
+  toOpenAiImagePart,
+} = require("./visionBlocks");
 
 /**
  * OpenAI-compatible chat-completions transport adapter.
@@ -82,11 +88,23 @@ function createOpenAiChatTransport(deps = {}) {
       }));
     },
     appendToolResult({ messages, call, toolResult }) {
+      const vision = extractVisionPayload(toolResult);
+      const payload = vision ? stripVisionBase64(toolResult) : toolResult;
       messages.push({
         role: "tool",
         tool_call_id: call.source.id,
-        content: clipText(toJsonString(toolResult), 12000),
+        content: clipText(toJsonString(payload), 12000),
       });
+      if (vision) {
+        const imagePart = toOpenAiImagePart(vision);
+        messages.push({
+          role: "user",
+          content: [
+            { type: "text", text: visionSummaryText(vision, toolResult) },
+            imagePart,
+          ],
+        });
+      }
     },
   };
 

package/src/code/providers/visionBlocks.js

@@ -0,0 +1,110 @@
+"use strict";
+
+/**
+ * Helpers for expanding read_image tool results into provider vision blocks.
+ */
+
+function extractVisionPayload(toolResult = null) {
+  if (!toolResult || typeof toolResult !== "object") return null;
+  const base64 = String(toolResult.base64 || "").trim();
+  const mediaType = String(toolResult.mediaType || "").trim().toLowerCase();
+  if (!base64 || !mediaType.startsWith("image/")) return null;
+  if (toolResult.ok === false) return null;
+  return {
+    path: String(toolResult.path || "").trim(),
+    mediaType,
+    bytes: Number.isFinite(toolResult.bytes) ? toolResult.bytes : null,
+    base64,
+    artifactId: String(toolResult.artifactId || "").trim(),
+  };
+}
+
+function isVisionToolResult(toolResult = null) {
+  return Boolean(extractVisionPayload(toolResult));
+}
+
+function stripVisionBase64(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => stripVisionBase64(item));
+  }
+  if (!value || typeof value !== "object") return value;
+  const out = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (key === "base64") continue;
+    out[key] = stripVisionBase64(entry);
+  }
+  return out;
+}
+
+function visionSummaryText(vision = null, toolResult = null) {
+  const pathText = (vision && vision.path) || (toolResult && toolResult.path) || "image";
+  const mediaType = (vision && vision.mediaType) || (toolResult && toolResult.mediaType) || "image/*";
+  const bytes = (vision && vision.bytes) != null
+    ? vision.bytes
+    : (toolResult && toolResult.bytes);
+  const parts = [
+    `Image loaded for vision: ${pathText}`,
+    `mediaType=${mediaType}`,
+  ];
+  if (Number.isFinite(bytes)) parts.push(`bytes=${bytes}`);
+  if (vision && vision.artifactId) parts.push(`artifactId=${vision.artifactId}`);
+  parts.push("Visual content is attached for this model call only; call read_image again later if needed.");
+  return parts.join(" | ");
+}
+
+function toAnthropicImageBlock(vision = null) {
+  if (!vision) return null;
+  return {
+    type: "image",
+    source: {
+      type: "base64",
+      media_type: vision.mediaType,
+      data: vision.base64,
+    },
+  };
+}
+
+function toOpenAiImagePart(vision = null) {
+  if (!vision) return null;
+  return {
+    type: "image_url",
+    image_url: {
+      url: `data:${vision.mediaType};base64,${vision.base64}`,
+    },
+  };
+}
+
+function degradeVisionContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return content;
+  const texts = [];
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue;
+    const type = String(block.type || "").trim().toLowerCase();
+    if (type === "text" && block.text) {
+      texts.push(String(block.text));
+      continue;
+    }
+    if (type === "image" || type === "image_url") {
+      const pathHint = block.path
+        || (block.source && block.source.path)
+        || "";
+      texts.push(pathHint ? `[image: ${pathHint}]` : "[image]");
+      continue;
+    }
+    if (type === "tool_result" && Array.isArray(block.content)) {
+      texts.push(degradeVisionContent(block.content));
+    }
+  }
+  return texts.filter(Boolean).join("\n") || "[multimodal content]";
+}
+
+module.exports = {
+  extractVisionPayload,
+  isVisionToolResult,
+  stripVisionBase64,
+  visionSummaryText,
+  toAnthropicImageBlock,
+  toOpenAiImagePart,
+  degradeVisionContent,
+};

package/src/code/repl.js

@@ -113,21 +113,24 @@ function runSingleCommand(line = "", workspaceRoot = process.cwd()) {
   }
   const modelMatch = text.match(/^(?:\/model|model)(?:\s+(.*))?$/i);
   if (modelMatch) {
-    const nextModel = String(modelMatch[1] || "").trim();
-    if (!nextModel) {
+    const rest = String(modelMatch[1] || "").trim();
+    if (!rest) {
       return { kind: "model", action: "show" };
     }
-    // Reject accidental multi-token garbage; model ids are single tokens.
-    if (/\s/.test(nextModel)) {
+    const parts = rest.split(/\s+/).filter(Boolean);
+    const modelId = parts[0] || "";
+    const thinking = parts[1] || "";
+    if (!modelId || parts.length > 2) {
       return {
         kind: "error",
-        output: "usage: /model [model-id]",
+        output: "usage: /model [model-id] [off|low|medium|high|max]",
       };
     }
     return {
       kind: "model",
       action: "set",
-      model: nextModel,
+      model: modelId,
+      thinking,
     };
   }
   const planMatch = text.match(/^(?:\/plan|plan)(?:\s+(.*))?$/i);
@@ -291,10 +294,29 @@ async function runUcodeCoreAgent({
     provider,
     model,
   });
+  const {
+    currentThinkingLevel,
+  } = require("./modelCommand");
+  const {
+    resolveThinkingFromEnvAndConfig,
+    applyThinkingLevelToEnv,
+  } = require("./thinkingLevels");
+  const { loadGlobalUcodeConfig } = require("../config");
+  let initialThinking = "";
+  try {
+    initialThinking = String((loadGlobalUcodeConfig() || {}).ucodeThinking || "").trim();
+  } catch {
+    initialThinking = "";
+  }
+  const thinkingResolved = resolveThinkingFromEnvAndConfig({
+    env: process.env,
+    configLevel: initialThinking,
+  });
   const state = {
     workspaceRoot: resolvedWorkspaceRoot,
     provider: resolvedUcode.provider,
     model: resolvedUcode.model,
+    thinking: currentThinkingLevel({ thinking: initialThinking }),
     engine: "ufoo-core",
     context: buildNlContext({
       appendSystemPrompt,
@@ -308,6 +330,10 @@ async function runUcodeCoreAgent({
     timeoutMs: resolveNlTaskTimeoutMs(Number.isFinite(timeoutMs) && timeoutMs > 0 ? timeoutMs : NaN),
     jsonOutput,
   };
+  // Named levels sync into env; leave an explicit numeric budget override alone.
+  if (thinkingResolved.source !== "env-budget") {
+    applyThinkingLevelToEnv(state.thinking, process.env);
+  }
   persistSessionState(state);
 
   if (shouldUseUcodeTui({
@@ -466,7 +492,9 @@ async function runUcodeCoreAgent({
         }
       }
       if (result.kind === "model") {
-        const applied = applyUcodeModelCommand(state, result);
+        const applied = await applyUcodeModelCommand(state, result, {
+          workspaceRoot: runtimeWorkspace,
+        });
         stdout.write(`${applied.output}\n`);
         if (applied.ok && result.action === "set") {
           persistSessionState(state);
@@ -770,4 +798,5 @@ module.exports = {
   applyUcodeModelCommand,
   applyUcodePlanCommand,
   suggestUcodeModels,
-};
+  suggestUcodeThinkingLevels: require("./modelCommand").suggestUcodeThinkingLevels,
+};

package/src/code/runtime/taskControl.js

@@ -1,8 +1,10 @@
 "use strict";
 
 /**
- * plan_graph control-plane actions:
- * start_task / cancel_task / fail_task / complete_task / skip_node / cancel_subtree.
+ * Control-plane TaskRun lifecycle:
+ * - startTask: graph-bound TaskRun from a plan_graph task_loop node
+ * - startStandaloneTask: single-point TaskRun (no plan graph / Plan Mode required)
+ * - cancel/fail/complete by nodeId or taskRunId
  *
  * complete_task:
  * - taskRunId → owning TaskLoop submitting TaskRun result
@@ -59,6 +61,44 @@ function dependenciesSatisfied(parent = null, node = null) {
   return { ok: unmet.length === 0, dependencies: unmet };
 }
 
+function rejectMaxConcurrent(executionState = null) {
+  const activeCount = listActiveWritingTaskRuns(executionState).length;
+  const leaseCount = countWriteLeases(executionState);
+  if (activeCount >= MAX_CONCURRENT_WRITE_LEASES || leaseCount >= MAX_CONCURRENT_WRITE_LEASES) {
+    return {
+      status: "rejected",
+      ok: false,
+      errors: [{
+        code: "MAX_CONCURRENT_TASKS",
+        message: `At most ${MAX_CONCURRENT_WRITE_LEASES} concurrent writing TaskRuns`,
+        max: MAX_CONCURRENT_WRITE_LEASES,
+        current: Math.max(activeCount, leaseCount),
+      }],
+    };
+  }
+  return null;
+}
+
+function resolveActiveRun(executionState = null, {
+  nodeId = "",
+  taskRunId = "",
+} = {}) {
+  const runId = String(taskRunId || "").trim();
+  if (runId) {
+    const run = getTaskRun(executionState, runId);
+    if (!run) return { run: null, errorCode: "TASK_RUN_NOT_FOUND" };
+    if (run.status === "queued" || run.status === "running" || run.status === "cancelling") {
+      return { run, errorCode: "" };
+    }
+    return { run, errorCode: "TASK_ALREADY_TERMINAL" };
+  }
+  const id = String(nodeId || "").trim();
+  if (!id) return { run: null, errorCode: "TASK_NOT_RUNNING" };
+  const active = findActiveTaskRunForNode(executionState, id);
+  if (active) return { run: active, errorCode: "" };
+  return { run: null, errorCode: "TASK_NOT_RUNNING" };
+}
+
 function startTask(executionState = null, {
   nodeId = "",
   commandId = "",
@@ -125,20 +165,8 @@ function startTask(executionState = null, {
     };
   }
 
-  const activeCount = listActiveWritingTaskRuns(executionState).length;
-  const leaseCount = countWriteLeases(executionState);
-  if (activeCount >= MAX_CONCURRENT_WRITE_LEASES || leaseCount >= MAX_CONCURRENT_WRITE_LEASES) {
-    return {
-      status: "rejected",
-      ok: false,
-      errors: [{
-        code: "MAX_CONCURRENT_TASKS",
-        message: `At most ${MAX_CONCURRENT_WRITE_LEASES} concurrent writing TaskRuns`,
-        max: MAX_CONCURRENT_WRITE_LEASES,
-        current: Math.max(activeCount, leaseCount),
-      }],
-    };
-  }
+  const limited = rejectMaxConcurrent(executionState);
+  if (limited) return limited;
 
   // Freeze spec snapshot on node.runtime
   if (!node.runtime || typeof node.runtime !== "object") node.runtime = {};
@@ -151,16 +179,20 @@ function startTask(executionState = null, {
       : { kind: "task_loop" },
   };
 
+  const objective = node.objective || node.title || id;
   const run = createTaskRun({
+    kind: "graph_node",
     parentGraphId: parent.graphId || "",
     parentNodeId: id,
     attempt: (Number(node.attempt) || 0) + 1,
+    objective,
+    title: node.title || objective,
   });
   const child = createChildGraphState({
     parentGraphId: parent.graphId || "",
     parentNodeId: id,
     taskRunId: run.id,
-    objective: node.objective || node.title || id,
+    objective,
   });
   run.childGraphId = child.graphId;
   putTaskRun(executionState, run);
@@ -192,37 +224,116 @@ function startTask(executionState = null, {
   return payload;
 }
 
+/**
+ * Start a TaskRun that is not attached to any plan_graph node.
+ * Orthogonal to Plan Mode: never enters or requires Plan Mode.
+ */
+function startStandaloneTask(executionState = null, {
+  objective = "",
+  title = "",
+  commandId = "",
+  runTool = null,
+  knownTools = null,
+  processImmediately = true,
+} = {}) {
+  const cached = getCachedControlCommand(executionState, commandId);
+  if (cached) return { ...cached, idempotentReplay: true };
+
+  ensureGraphs(executionState);
+
+  const goal = String(objective || title || "").trim();
+  if (!goal) {
+    return {
+      status: "rejected",
+      ok: false,
+      errors: [{ code: "OBJECTIVE_REQUIRED", message: "standalone task requires objective" }],
+    };
+  }
+
+  const limited = rejectMaxConcurrent(executionState);
+  if (limited) return limited;
+
+  const run = createTaskRun({
+    kind: "standalone",
+    parentGraphId: "",
+    parentNodeId: "",
+    attempt: 1,
+    objective: goal,
+    title: String(title || goal).trim(),
+  });
+  const child = createChildGraphState({
+    parentGraphId: "",
+    parentNodeId: "",
+    taskRunId: run.id,
+    objective: goal,
+  });
+  run.childGraphId = child.graphId;
+  putTaskRun(executionState, run);
+  setGraph(executionState, child);
+
+  const payload = {
+    status: "started",
+    ok: true,
+    kind: "standalone",
+    graphId: "",
+    nodeId: "",
+    taskRunId: run.id,
+    childGraphId: child.graphId,
+    objective: goal,
+    title: run.title,
+    parentNodeStatus: "",
+  };
+  cacheControlCommand(executionState, commandId, payload);
+
+  enqueueTaskEvent(executionState, run.id, { kind: "advance" });
+
+  if (processImmediately) {
+    processTaskRun(executionState, run.id, { runTool, knownTools });
+  }
+
+  return payload;
+}
+
 function cancelTask(executionState = null, {
   nodeId = "",
+  taskRunId = "",
   reason = "",
   commandId = "",
 } = {}) {
   const cached = getCachedControlCommand(executionState, commandId);
   if (cached) return { ...cached, idempotentReplay: true };
 
-  const id = String(nodeId || "").trim();
-  const active = findActiveTaskRunForNode(executionState, id);
-  if (!active) {
-    const { node } = findParentNode(executionState, id);
-    if (node && (node.status === "succeeded" || node.status === "failed" || node.status === "cancelled")) {
-      return {
-        status: "rejected",
-        ok: false,
-        errors: [{
-          code: "TASK_ALREADY_TERMINAL",
-          message: `task ${id} already ${node.status}`,
-          currentStatus: node.status,
-        }],
-      };
+  const resolved = resolveActiveRun(executionState, { nodeId, taskRunId });
+  const active = resolved.run;
+  if (!active || resolved.errorCode === "TASK_RUN_NOT_FOUND") {
+    const id = String(nodeId || "").trim();
+    if (id) {
+      const { node } = findParentNode(executionState, id);
+      if (node && (node.status === "succeeded" || node.status === "failed" || node.status === "cancelled")) {
+        return {
+          status: "rejected",
+          ok: false,
+          errors: [{
+            code: "TASK_ALREADY_TERMINAL",
+            message: `task ${id} already ${node.status}`,
+            currentStatus: node.status,
+          }],
+        };
+      }
     }
     return {
       status: "rejected",
       ok: false,
-      errors: [{ code: "TASK_NOT_RUNNING", message: `no active run for ${id}` }],
+      errors: [{
+        code: resolved.errorCode || "TASK_NOT_RUNNING",
+        message: taskRunId
+          ? `no active run for taskRunId ${taskRunId}`
+          : `no active run for ${nodeId || "(missing id)"}`,
+      }],
     };
   }
 
-  if (isTerminalTaskRun(active)) {
+  if (isTerminalTaskRun(active) || resolved.errorCode === "TASK_ALREADY_TERMINAL") {
     return {
       status: "rejected",
       ok: false,
@@ -252,7 +363,7 @@ function cancelTask(executionState = null, {
   const payload = {
     status: "accepted",
     ok: Boolean(done.ok),
-    nodeId: id,
+    nodeId: active.parentNodeId || "",
     taskRunId: active.id,
     parentNodeStatus: done.run ? done.run.status : "cancelled",
   };
@@ -262,34 +373,43 @@ function cancelTask(executionState = null, {
 
 function failTask(executionState = null, {
   nodeId = "",
+  taskRunId = "",
   reason = "",
   commandId = "",
 } = {}) {
   const cached = getCachedControlCommand(executionState, commandId);
   if (cached) return { ...cached, idempotentReplay: true };
 
-  const id = String(nodeId || "").trim();
-  const active = findActiveTaskRunForNode(executionState, id);
-  if (!active) {
-    const { node } = findParentNode(executionState, id);
-    if (node && (node.status === "succeeded" || node.status === "failed" || node.status === "cancelled")) {
-      return {
-        status: "rejected",
-        ok: false,
-        errors: [{
-          code: "TASK_ALREADY_TERMINAL",
-          message: `task ${id} already ${node.status}`,
-          currentStatus: node.status,
-        }],
-      };
+  const resolved = resolveActiveRun(executionState, { nodeId, taskRunId });
+  const active = resolved.run;
+  if (!active || resolved.errorCode === "TASK_RUN_NOT_FOUND") {
+    const id = String(nodeId || "").trim();
+    if (id) {
+      const { node } = findParentNode(executionState, id);
+      if (node && (node.status === "succeeded" || node.status === "failed" || node.status === "cancelled")) {
+        return {
+          status: "rejected",
+          ok: false,
+          errors: [{
+            code: "TASK_ALREADY_TERMINAL",
+            message: `task ${id} already ${node.status}`,
+            currentStatus: node.status,
+          }],
+        };
+      }
     }
     return {
       status: "rejected",
       ok: false,
-      errors: [{ code: "TASK_NOT_RUNNING", message: `no active run for ${id}` }],
+      errors: [{
+        code: resolved.errorCode || "TASK_NOT_RUNNING",
+        message: taskRunId
+          ? `no active run for taskRunId ${taskRunId}`
+          : `no active run for ${nodeId || "(missing id)"}`,
+      }],
     };
   }
-  if (isTerminalTaskRun(active)) {
+  if (isTerminalTaskRun(active) || resolved.errorCode === "TASK_ALREADY_TERMINAL") {
     return {
       status: "rejected",
       ok: false,
@@ -313,7 +433,7 @@ function failTask(executionState = null, {
   const payload = {
     status: done.ok ? "accepted" : "rejected",
     ok: Boolean(done.ok),
-    nodeId: id,
+    nodeId: active.parentNodeId || "",
     taskRunId: active.id,
     parentNodeStatus: done.run ? done.run.status : "failed",
     errors: done.ok ? undefined : [{ code: done.code || "CAS_FAILED", currentStatus: done.currentStatus }],
@@ -485,14 +605,16 @@ function runControlActions(executionState = null, {
     } else if (op === "cancel_task") {
       results.push(cancelTask(executionState, {
         nodeId: action.nodeId,
+        taskRunId: action.taskRunId,
         reason: action.reason,
-        commandId: commandId && list.length === 1 ? commandId : `${commandId}:${op}:${action.nodeId}`,
+        commandId: commandId && list.length === 1 ? commandId : `${commandId}:${op}:${action.nodeId || action.taskRunId}`,
       }));
     } else if (op === "fail_task" || op === "mark_task_failed") {
       results.push(failTask(executionState, {
         nodeId: action.nodeId,
+        taskRunId: action.taskRunId,
         reason: action.reason,
-        commandId: commandId && list.length === 1 ? commandId : `${commandId}:${op}:${action.nodeId}`,
+        commandId: commandId && list.length === 1 ? commandId : `${commandId}:${op}:${action.nodeId || action.taskRunId}`,
       }));
     } else if (op === "complete_task") {
       const taskRunId = String(action.taskRunId || "").trim();
@@ -528,6 +650,7 @@ function runControlActions(executionState = null, {
     } else if (op === "fail_current_task") {
       results.push(failTask(executionState, {
         nodeId: action.nodeId || (getTaskRun(executionState, action.taskRunId) || {}).parentNodeId,
+        taskRunId: action.taskRunId,
         reason: action.reason,
         commandId: commandId && list.length === 1 ? commandId : `${commandId}:${op}`,
       }));
@@ -554,6 +677,7 @@ function runControlActions(executionState = null, {
 
 module.exports = {
   startTask,
+  startStandaloneTask,
   cancelTask,
   failTask,
   completeTaskFromLoop,

package/src/code/runtime/taskFocus.js

@@ -82,6 +82,7 @@ function buildTaskFocus({
   currentNodeId = "",
   taskRunsById = {},
   recentlyChangedFiles = [],
+  standaloneTask = null,
 } = {}) {
   const byId = new Map((Array.isArray(nodes) ? nodes : []).map((n) => [n.id, n]));
   const current = byId.get(currentNodeId);
@@ -96,19 +97,38 @@ function buildTaskFocus({
   });
   const writers = Object.values(runs)
     .filter((r) => r && (r.status === "running" || r.status === "cancelling"))
-    .map((r) => r.parentNodeId)
+    .map((r) => r.parentNodeId || r.id)
     .filter(Boolean);
 
+  let currentTask;
+  if (standaloneTask && typeof standaloneTask === "object") {
+    currentTask = {
+      id: standaloneTask.id || currentNodeId || "standalone",
+      objective: standaloneTask.objective || standaloneTask.title || "",
+      title: standaloneTask.title || standaloneTask.objective || standaloneTask.id || "standalone",
+      status: standaloneTask.status || (currentRun && currentRun.status) || "running",
+    };
+  } else if (current) {
+    currentTask = {
+      id: current.id,
+      objective: current.objective || current.title || "",
+      title: current.title || current.objective || current.id,
+      status: (currentRun && currentRun.status) || current.status,
+    };
+  } else {
+    currentTask = {
+      id: currentNodeId || "standalone",
+      objective: "",
+      title: currentNodeId || "standalone",
+      status: "unknown",
+    };
+  }
+
   return {
-    currentTask: current
-      ? {
-        id: current.id,
-        objective: current.objective || current.title || "",
-        title: current.title || current.objective || current.id,
-        status: (currentRun && currentRun.status) || current.status,
-      }
-      : { id: currentNodeId, objective: "", title: currentNodeId, status: "unknown" },
-    dependencies: listDependencySummaries(nodes, currentNodeId, runs),
+    currentTask,
+    dependencies: currentNodeId
+      ? listDependencySummaries(nodes, currentNodeId, runs)
+      : [],
     parallelSiblings: siblings,
     workspace: {
       concurrentWriters: writers,

package/src/code/runtime/taskLoop.js

@@ -242,12 +242,23 @@ function processTaskRun(executionState = null, taskRunId = "", options = {}) {
     }
   }
 
-  const parent = getGraph(executionState, live.parentGraphId) || executionState.planGraph;
+  const parent = live.parentGraphId
+    ? (getGraph(executionState, live.parentGraphId) || executionState.planGraph)
+    : null;
+  const standalone = !live.parentNodeId;
   const focus = buildTaskFocus({
     nodes: parent && parent.nodes ? parent.nodes : [],
     currentNodeId: live.parentNodeId,
     taskRunsById: (executionState.taskRuns && executionState.taskRuns.byId) || {},
     recentlyChangedFiles: executionState.modifiedFiles || [],
+    standaloneTask: standalone
+      ? {
+        id: live.id,
+        objective: live.objective || live.title || "",
+        title: live.title || live.objective || live.id,
+        status: live.status,
+      }
+      : null,
   });
   live.lastFocusText = renderTaskFocusText(focus);
   putTaskRun(executionState, live);

package/src/code/runtime/taskRun.js

@@ -93,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,