u-foo 2.5.15 → 3.0.0

package/src/code/runtime/taskRun.js

@@ -0,0 +1,187 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+
+/**
+ * TaskRun registry — parent Task node identity vs runnable attempt.
+ */
+
+const TASK_RUN_STATUSES = Object.freeze([
+  "queued",
+  "running",
+  "cancelling",
+  "succeeded",
+  "failed",
+  "cancelled",
+]);
+
+const TASK_RUN_PHASES = Object.freeze([
+  "initializing",
+  "planning",
+  "waiting_model",
+  "executing_tools",
+  "finalizing",
+]);
+
+const TERMINAL_TASK_RUN = new Set(["succeeded", "failed", "cancelled"]);
+
+function createTaskRunId() {
+  return `trun_${Date.now().toString(36)}_${randomUUID().slice(0, 6)}`;
+}
+
+function emptyTaskRunStore() {
+  return {
+    byId: {},
+    commandLog: {},
+  };
+}
+
+function ensureTaskRunStore(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.taskRuns || typeof state.taskRuns !== "object") {
+    state.taskRuns = emptyTaskRunStore();
+  }
+  if (!state.taskRuns.byId || typeof state.taskRuns.byId !== "object") {
+    state.taskRuns.byId = {};
+  }
+  if (!state.taskRuns.commandLog || typeof state.taskRuns.commandLog !== "object") {
+    state.taskRuns.commandLog = {};
+  }
+  return state.taskRuns;
+}
+
+function createTaskRun({
+  parentGraphId = "",
+  parentNodeId = "",
+  childGraphId = "",
+  attempt = 1,
+} = {}) {
+  const now = new Date().toISOString();
+  return {
+    id: createTaskRunId(),
+    parentGraphId: String(parentGraphId || "").trim(),
+    parentNodeId: String(parentNodeId || "").trim(),
+    childGraphId: String(childGraphId || "").trim(),
+    status: "queued",
+    phase: "initializing",
+    attempt: Number.isFinite(attempt) ? Math.max(1, Math.floor(attempt)) : 1,
+    ignoreUserPrompts: true,
+    cancelRequested: false,
+    result: null,
+    error: null,
+    changedFiles: [],
+    createdAt: now,
+    startedAt: "",
+    completedAt: "",
+  };
+}
+
+function getTaskRun(executionState = null, taskRunId = "") {
+  const store = ensureTaskRunStore(executionState);
+  const id = String(taskRunId || "").trim();
+  return id && store.byId[id] ? store.byId[id] : null;
+}
+
+function putTaskRun(executionState = null, taskRun = null) {
+  if (!taskRun || !taskRun.id) return null;
+  const store = ensureTaskRunStore(executionState);
+  store.byId[taskRun.id] = taskRun;
+  return taskRun;
+}
+
+function findActiveTaskRunForNode(executionState = null, parentNodeId = "") {
+  const store = ensureTaskRunStore(executionState);
+  const nodeId = String(parentNodeId || "").trim();
+  for (const run of Object.values(store.byId)) {
+    if (!run || run.parentNodeId !== nodeId) continue;
+    if (run.status === "queued" || run.status === "running" || run.status === "cancelling") {
+      return run;
+    }
+  }
+  return null;
+}
+
+function listActiveWritingTaskRuns(executionState = null) {
+  const store = ensureTaskRunStore(executionState);
+  return Object.values(store.byId).filter((run) => (
+    run
+    && (run.status === "queued" || run.status === "running" || run.status === "cancelling")
+  ));
+}
+
+function isTerminalTaskRun(run = null) {
+  return Boolean(run && TERMINAL_TASK_RUN.has(String(run.status || "")));
+}
+
+/**
+ * Compare-and-set status transition. Returns { ok, run }.
+ */
+function casTaskRunStatus(executionState = null, taskRunId = "", {
+  expectedStatus = "",
+  nextStatus = "",
+  phase = "",
+  result = null,
+  error = null,
+  changedFiles = null,
+} = {}) {
+  const run = getTaskRun(executionState, taskRunId);
+  if (!run) return { ok: false, code: "TASK_RUN_NOT_FOUND", run: null };
+  const expected = String(expectedStatus || "").trim();
+  if (expected && run.status !== expected) {
+    return {
+      ok: false,
+      code: "TASK_STATUS_CAS_FAILED",
+      run,
+      currentStatus: run.status,
+    };
+  }
+  const next = String(nextStatus || "").trim();
+  if (!TASK_RUN_STATUSES.includes(next)) {
+    return { ok: false, code: "INVALID_TASK_STATUS", run };
+  }
+  run.status = next;
+  if (phase && TASK_RUN_PHASES.includes(phase)) run.phase = phase;
+  if (result !== null) run.result = result;
+  if (error !== null) run.error = error;
+  if (Array.isArray(changedFiles)) run.changedFiles = changedFiles.map(String);
+  if (next === "running" && !run.startedAt) run.startedAt = new Date().toISOString();
+  if (TERMINAL_TASK_RUN.has(next)) {
+    run.completedAt = new Date().toISOString();
+    run.phase = "finalizing";
+  }
+  if (next === "cancelling") run.cancelRequested = true;
+  putTaskRun(executionState, run);
+  return { ok: true, run };
+}
+
+function cacheControlCommand(executionState = null, commandId = "", payload = {}) {
+  const id = String(commandId || "").trim();
+  if (!id) return;
+  const store = ensureTaskRunStore(executionState);
+  store.commandLog[id] = JSON.parse(JSON.stringify(payload));
+}
+
+function getCachedControlCommand(executionState = null, commandId = "") {
+  const id = String(commandId || "").trim();
+  if (!id) return null;
+  const store = ensureTaskRunStore(executionState);
+  return store.commandLog[id] ? JSON.parse(JSON.stringify(store.commandLog[id])) : null;
+}
+
+module.exports = {
+  TASK_RUN_STATUSES,
+  TASK_RUN_PHASES,
+  TERMINAL_TASK_RUN,
+  createTaskRunId,
+  emptyTaskRunStore,
+  ensureTaskRunStore,
+  createTaskRun,
+  getTaskRun,
+  putTaskRun,
+  findActiveTaskRunForNode,
+  listActiveWritingTaskRuns,
+  isTerminalTaskRun,
+  casTaskRunStatus,
+  cacheControlCommand,
+  getCachedControlCommand,
+};

package/src/code/runtime/toolProvenance.js

@@ -0,0 +1,70 @@
+"use strict";
+
+/**
+ * Per-TaskRun tool provenance for changedFiles (not git diff attribution).
+ */
+
+function ensureProvenanceStore(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.toolProvenance || typeof state.toolProvenance !== "object") {
+    state.toolProvenance = { byTaskRunId: {} };
+  }
+  if (!state.toolProvenance.byTaskRunId || typeof state.toolProvenance.byTaskRunId !== "object") {
+    state.toolProvenance.byTaskRunId = {};
+  }
+  return state.toolProvenance;
+}
+
+function touchedPathsFromTool(tool = "", args = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  const paths = [];
+  if (name === "write" || name === "edit") {
+    const path = String(args && args.path || "").trim();
+    if (path) paths.push(path);
+  }
+  return paths;
+}
+
+function recordToolProvenance(executionState = null, {
+  taskRunId = "",
+  tool = "",
+  args = {},
+  graphId = "",
+  nodeId = "",
+} = {}) {
+  const id = String(taskRunId || "").trim();
+  if (!id) return [];
+  const store = ensureProvenanceStore(executionState);
+  if (!store.byTaskRunId[id]) {
+    store.byTaskRunId[id] = { paths: [], events: [] };
+  }
+  const bucket = store.byTaskRunId[id];
+  const paths = touchedPathsFromTool(tool, args);
+  for (const path of paths) {
+    if (!bucket.paths.includes(path)) bucket.paths.push(path);
+  }
+  bucket.events.push({
+    at: new Date().toISOString(),
+    tool: String(tool || ""),
+    graphId: String(graphId || ""),
+    nodeId: String(nodeId || ""),
+    paths,
+  });
+  // Cap event log
+  if (bucket.events.length > 200) bucket.events = bucket.events.slice(-200);
+  return paths;
+}
+
+function getProvenanceChangedFiles(executionState = null, taskRunId = "") {
+  const store = ensureProvenanceStore(executionState);
+  const id = String(taskRunId || "").trim();
+  const bucket = store.byTaskRunId[id];
+  return bucket && Array.isArray(bucket.paths) ? bucket.paths.slice() : [];
+}
+
+module.exports = {
+  ensureProvenanceStore,
+  touchedPathsFromTool,
+  recordToolProvenance,
+  getProvenanceChangedFiles,
+};

package/src/code/runtime/workspaceLease.js

@@ -0,0 +1,208 @@
+"use strict";
+
+/**
+ * Workspace write lease — up to MAX_CONCURRENT_WRITE_LEASES writing TaskRuns.
+ * Agent write/edit/side-effect bash rejected while any Task holds a write lease.
+ */
+
+const WRITE_TOOLS = new Set(["write", "edit", "bash"]);
+const MAX_CONCURRENT_WRITE_LEASES = 6;
+
+function emptyWorkspaceLease() {
+  return {
+    holders: [], // [{ kind: "task_run", taskRunId, acquiredAt }]
+    mode: "write",
+    // Legacy single-holder field; migrated in ensureWorkspaceLease.
+    holder: null,
+    acquiredAt: "",
+  };
+}
+
+function ensureWorkspaceLease(executionState = null) {
+  const state = executionState && typeof executionState === "object" ? executionState : {};
+  if (!state.workspaceLease || typeof state.workspaceLease !== "object") {
+    state.workspaceLease = emptyWorkspaceLease();
+  }
+  normalizeHolders(state.workspaceLease);
+  return state.workspaceLease;
+}
+
+function normalizeHolders(lease = null) {
+  const next = lease && typeof lease === "object" ? lease : emptyWorkspaceLease();
+  if (!Array.isArray(next.holders)) next.holders = [];
+
+  // Migrate V1 single-holder shape.
+  if (next.holder && typeof next.holder === "object" && next.holder.taskRunId) {
+    const id = String(next.holder.taskRunId || "").trim();
+    if (id && !next.holders.some((h) => h && h.taskRunId === id)) {
+      next.holders.push({
+        kind: "task_run",
+        taskRunId: id,
+        acquiredAt: String(next.acquiredAt || new Date().toISOString()),
+      });
+    }
+    next.holder = null;
+  }
+
+  next.holders = next.holders
+    .filter((h) => h && h.kind === "task_run" && String(h.taskRunId || "").trim())
+    .map((h) => ({
+      kind: "task_run",
+      taskRunId: String(h.taskRunId).trim(),
+      acquiredAt: String(h.acquiredAt || ""),
+    }));
+
+  // Cap defensive (should not happen if acquire gates correctly).
+  if (next.holders.length > MAX_CONCURRENT_WRITE_LEASES) {
+    next.holders = next.holders.slice(0, MAX_CONCURRENT_WRITE_LEASES);
+  }
+  return next.holders;
+}
+
+function listWriteLeaseHolders(executionState = null) {
+  return normalizeHolders(ensureWorkspaceLease(executionState)).slice();
+}
+
+function countWriteLeases(executionState = null) {
+  return listWriteLeaseHolders(executionState).length;
+}
+
+function findWriteLeaseHolder(executionState = null, taskRunId = "") {
+  const id = String(taskRunId || "").trim();
+  if (!id) return null;
+  return listWriteLeaseHolders(executionState).find((h) => h.taskRunId === id) || null;
+}
+
+function canAcquireWriteLease(executionState = null, taskRunId = "") {
+  const id = String(taskRunId || "").trim();
+  if (!id) return { ok: false, code: "MISSING_TASK_RUN_ID" };
+  if (findWriteLeaseHolder(executionState, id)) {
+    return { ok: true, idempotent: true };
+  }
+  const count = countWriteLeases(executionState);
+  if (count >= MAX_CONCURRENT_WRITE_LEASES) {
+    return {
+      ok: false,
+      code: "MAX_CONCURRENT_TASKS",
+      max: MAX_CONCURRENT_WRITE_LEASES,
+      current: count,
+      holders: listWriteLeaseHolders(executionState),
+    };
+  }
+  return { ok: true, current: count, max: MAX_CONCURRENT_WRITE_LEASES };
+}
+
+function acquireTaskWriteLease(executionState = null, taskRunId = "") {
+  const lease = ensureWorkspaceLease(executionState);
+  const holders = normalizeHolders(lease);
+  const id = String(taskRunId || "").trim();
+  if (!id) {
+    return { ok: false, code: "MISSING_TASK_RUN_ID" };
+  }
+
+  const existing = holders.find((h) => h.taskRunId === id);
+  if (existing) {
+    return { ok: true, lease, holder: existing, idempotent: true };
+  }
+
+  if (holders.length >= MAX_CONCURRENT_WRITE_LEASES) {
+    return {
+      ok: false,
+      code: "MAX_CONCURRENT_TASKS",
+      max: MAX_CONCURRENT_WRITE_LEASES,
+      current: holders.length,
+      holders: holders.slice(),
+      message: `At most ${MAX_CONCURRENT_WRITE_LEASES} concurrent writing TaskRuns`,
+    };
+  }
+
+  const holder = {
+    kind: "task_run",
+    taskRunId: id,
+    acquiredAt: new Date().toISOString(),
+  };
+  holders.push(holder);
+  lease.holders = holders;
+  lease.mode = "write";
+  return { ok: true, lease, holder };
+}
+
+function releaseTaskWriteLease(executionState = null, taskRunId = "") {
+  const lease = ensureWorkspaceLease(executionState);
+  const holders = normalizeHolders(lease);
+  const id = String(taskRunId || "").trim();
+  if (!id) return { ok: true, lease };
+  lease.holders = holders.filter((h) => h.taskRunId !== id);
+  if (lease.holders.length === 0) {
+    lease.acquiredAt = "";
+  }
+  return { ok: true, lease };
+}
+
+function clearWorkspaceLease(executionState = null) {
+  const lease = ensureWorkspaceLease(executionState);
+  lease.holders = [];
+  lease.holder = null;
+  lease.acquiredAt = "";
+  return lease;
+}
+
+/**
+ * @param {string} tool
+ * @param {"agent_loop"|"task_loop"} originKind
+ * @param {string} [taskRunId]
+ */
+function checkWriteAllowed(executionState = null, {
+  tool = "",
+  originKind = "agent_loop",
+  taskRunId = "",
+} = {}) {
+  const name = String(tool || "").trim().toLowerCase();
+  if (!WRITE_TOOLS.has(name)) return { ok: true };
+
+  const holders = listWriteLeaseHolders(executionState);
+  if (holders.length === 0) return { ok: true };
+
+  if (originKind === "task_loop") {
+    const id = String(taskRunId || "").trim();
+    if (holders.some((h) => h.taskRunId === id)) {
+      return { ok: true };
+    }
+    return {
+      ok: false,
+      code: "WORKSPACE_WRITE_LEASE_HELD",
+      holders,
+      message: "This TaskRun does not hold a workspace write lease.",
+    };
+  }
+
+  // Agent loop cannot write while any task holds a lease.
+  return {
+    ok: false,
+    code: "WORKSPACE_WRITE_LEASE_HELD",
+    holders,
+    owner: holders[0] || null,
+    message: `${holders.length} active TaskRun(s) hold workspace write lease(s); cancel or wait before writing.`,
+  };
+}
+
+function hasActiveWriteLease(executionState = null) {
+  return countWriteLeases(executionState) > 0;
+}
+
+module.exports = {
+  WRITE_TOOLS,
+  MAX_CONCURRENT_WRITE_LEASES,
+  emptyWorkspaceLease,
+  ensureWorkspaceLease,
+  normalizeHolders,
+  listWriteLeaseHolders,
+  countWriteLeases,
+  findWriteLeaseHolder,
+  canAcquireWriteLease,
+  acquireTaskWriteLease,
+  releaseTaskWriteLease,
+  clearWorkspaceLease,
+  checkWriteAllowed,
+  hasActiveWriteLease,
+};

package/src/code/sessionStore.js

@@ -1,7 +1,6 @@
 const fs = require("fs");
 const path = require("path");
 const { randomUUID } = require("crypto");
-const { isContextV2Enabled } = require("./context/featureFlag");
 const {
   getTranscriptsDir,
   getTranscriptFilePath,
@@ -72,7 +71,6 @@ function buildSessionSnapshot(input = {}) {
   const source = input && typeof input === "object" ? input : {};
   const sessionId = resolveSessionId(source.sessionId);
   const createdAt = String(source.createdAt || "").trim() || toIsoNow();
-  const useV2 = isContextV2Enabled() || Number(source.version) >= 2;
 
   const base = {
     sessionId,
@@ -84,14 +82,6 @@ function buildSessionSnapshot(input = {}) {
     updatedAt: toIsoNow(),
   };
 
-  if (!useV2) {
-    return {
-      version: 1,
-      ...base,
-      nlMessages: cloneMessages(source.nlMessages),
-    };
-  }
-
   return {
     version: 2,
     ...base,

package/src/code/skills/injection.js

@@ -195,4 +195,5 @@ module.exports = {
   readSkillBlock,
   persistSkillBodyArtifact,
   buildSkillInjections,
+  sanitizeSkillContent,
 };

package/src/code/taskDecomposer.js

@@ -4,8 +4,34 @@
  */
 
 const { runNativeAgentTask } = require("./nativeRunner");
-const { isContextV2Enabled } = require("./context/featureFlag");
 const { assembleModelContext, recordToolCallInSession } = require("./context/assembler");
+const fs = require("fs");
+const {
+  buildSkillManifest,
+  renderActiveSkillBlock,
+} = require("./skills");
+const { sanitizeSkillContent } = require("./skills/injection");
+
+function renderActiveSkillBodiesFromState(state = {}) {
+  const skills = Array.isArray(state.activeSkills) ? state.activeSkills : [];
+  const blocks = [];
+  for (const skill of skills) {
+    const skillPath = String(skill && skill.path || "").trim();
+    if (!skillPath) continue;
+    try {
+      const raw = fs.readFileSync(skillPath, "utf8");
+      const content = sanitizeSkillContent(raw);
+      const manifest = buildSkillManifest({
+        name: skill.name || "",
+        path: skillPath,
+      }, { bodyArtifactId: skill.bodyArtifactId || "" });
+      blocks.push(renderActiveSkillBlock(manifest, content));
+    } catch {
+      // ignore missing skill bodies
+    }
+  }
+  return blocks;
+}
 
 /**
  * Decompose a bug fix task into manageable steps
@@ -135,13 +161,11 @@ async function runDecomposedTask({
   messages = [],
   sessionId = "",
   state = null,
-  contextV2 = false,
   systemBlocks = null,
 }) {
   const steps = decomposeBugFixTask(task);
   const results = [];
   let aborted = false;
-  const useV2 = Boolean(contextV2 || isContextV2Enabled());
 
   // Check if already aborted
   if (signal && signal.aborted) {
@@ -174,12 +198,13 @@ async function runDecomposedTask({
       let stepMessages = messages;
       let stepSystemPrompt = systemPrompt;
       let stepSystemBlocks = systemBlocks;
-      if (useV2 && state) {
+      if (state) {
+        const skillBodies = renderActiveSkillBodiesFromState(state);
         const assembled = assembleModelContext(state, {
           workspaceRoot,
           model,
           provider,
-          turnDynamic: stepPrompt,
+          turnDynamic: [...skillBodies, stepPrompt].filter(Boolean).join("\n\n"),
         });
         stepMessages = assembled.messages;
         stepSystemPrompt = assembled.systemPrompt;
@@ -197,13 +222,12 @@ async function runDecomposedTask({
         timeoutMs: step.timeoutMs,
         onToolEvent,
         signal,
-        contextV2: useV2,
-        onArtifactPersisted: useV2 && state
+        onArtifactPersisted: state
           ? (persisted) => recordToolCallInSession(state, persisted, workspaceRoot)
           : null,
       });
 
-      if (useV2 && state && stepResult && Array.isArray(stepResult.messages)) {
+      if (state && stepResult && Array.isArray(stepResult.messages)) {
         const { syncMessagesToTranscript } = require("./context/assembler");
         syncMessagesToTranscript(state, stepResult.messages, workspaceRoot);
       }

package/src/code/tools/askUser.js

@@ -0,0 +1,11 @@
+"use strict";
+
+const { runAskUserTool } = require("../context/userInteraction");
+
+function runAskUserToolDispatch(args = {}, options = {}) {
+  return runAskUserTool(args, options);
+}
+
+module.exports = {
+  runAskUserTool: runAskUserToolDispatch,
+};

package/src/code/tools/planGraph.js

@@ -0,0 +1,29 @@
+"use strict";
+
+const {
+  runPlanGraphCommand,
+  normalizePlanGraphCommand,
+} = require("../context/planGraphService");
+
+function runPlanGraphTool(args = {}, options = {}) {
+  const command = normalizePlanGraphCommand(args) || args;
+  const result = runPlanGraphCommand(command, {
+    executionState: options.executionState,
+    runTool: options.runTool,
+    autoAdvance: options.autoAdvance !== false,
+    parallel: options.parallel !== false,
+    knownTools: options.knownTools,
+    maxNodeRuns: options.maxNodeRuns,
+  });
+
+  const payload = result.modelPayload || result;
+  return {
+    ok: payload.status === "accepted",
+    ...payload,
+    executionState: result.executionState,
+  };
+}
+
+module.exports = {
+  runPlanGraphTool,
+};

package/src/ui/format/index.js

@@ -129,7 +129,16 @@ function normalizeModelLabel(model = "") {
   return "default";
 }
 
-function buildUcodeBannerLines({ model = "", engine = "ufoo-core", nickname = "", agentId = "", workspaceRoot = "", sessionId = "", width = 0 } = {}) {
+function buildUcodeBannerLines({
+  model = "",
+  engine = "ufoo-core",
+  nickname = "",
+  agentId = "",
+  workspaceRoot = "",
+  sessionId = "",
+  width = 0,
+  planMode = false,
+} = {}) {
   const modelLabel = normalizeModelLabel(model);
   void width;
   void engine;
@@ -151,6 +160,9 @@ function buildUcodeBannerLines({ model = "", engine = "ufoo-core", nickname = ""
   const infoLines = [];
   infoLines.push(`${chalk.dim("Version:")} ${chalk.cyan.bold(UCODE_VERSION)}`);
   infoLines.push(`${chalk.dim("Model:")} ${chalk.yellow(modelLabel)}`);
+  if (planMode) {
+    infoLines.push(`${chalk.dim("Mode:")} ${chalk.magenta.bold("PLAN")}`);
+  }
   infoLines.push(`${chalk.dim("Dictionary:")} ${chalk.gray(shortPath)}`);
   const normalizedSessionId = String(sessionId || "").trim();
   if (normalizedSessionId) {
@@ -254,6 +266,16 @@ function renderLogLinesWithMarkdownAnsi(text = "", state = {}) {
   return renderMarkdownLinesAnsi(text, state);
 }
 
+function createMarkdownTableBuffer() {
+  const { createMarkdownTableBuffer: create } = require("./markdownRenderer");
+  return create();
+}
+
+function isTableRowLine(line = "") {
+  const { isTableRowLine: check } = require("./markdownRenderer");
+  return check(line);
+}
+
 function messageContentText(message = {}) {
   if (!message || typeof message !== "object") return "";
   const content = message.content;
@@ -1233,6 +1255,8 @@ module.exports = {
   planProjectsRail,
   renderLogLinesWithMarkdown,
   renderLogLinesWithMarkdownAnsi,
+  createMarkdownTableBuffer,
+  isTableRowLine,
   resolveAgentSelectionOnDown,
   resolveHistoryDownTransition,
   shouldClearAgentSelectionOnUp,