u-foo 3.0.0 → 3.0.1

package/src/code/providers/anthropicMessagesTransport.js

@@ -0,0 +1,93 @@
+"use strict";
+
+const { assertTransport } = require("./transportContract");
+
+/**
+ * Anthropic Messages API transport adapter.
+ * @param {{
+ *   resolveUrl: Function,
+ *   runTurn: Function,
+ *   toJsonString: Function,
+ *   clipText: Function,
+ * }} deps
+ */
+function createAnthropicMessagesTransport(deps = {}) {
+  const {
+    resolveUrl,
+    runTurn,
+    toJsonString,
+    clipText,
+  } = deps;
+
+  const transport = {
+    name: "anthropic-messages",
+    resolveUrl,
+    prepareMessages({ messages, prompt }) {
+      messages.push({
+        role: "user",
+        content: String(prompt || ""),
+      });
+    },
+    runTurn,
+    getToolCalls(turnResult) {
+      return Array.isArray(turnResult.toolCalls) ? turnResult.toolCalls : [];
+    },
+    appendFinalAssistantMessage({ messages, turnResult }) {
+      const assistantContent = Array.isArray(turnResult.assistantContent)
+        ? turnResult.assistantContent
+        : [];
+      if (assistantContent.length > 0) {
+        messages.push({
+          role: "assistant",
+          content: assistantContent,
+        });
+      } else if (String(turnResult.text || "").trim()) {
+        messages.push({
+          role: "assistant",
+          content: [
+            {
+              type: "text",
+              text: String(turnResult.text || ""),
+            },
+          ],
+        });
+      }
+    },
+    prepareToolCalls({ messages, turnResult, toolCalls }) {
+      const assistantContent = Array.isArray(turnResult.assistantContent)
+        ? turnResult.assistantContent
+        : [];
+
+      messages.push({
+        role: "assistant",
+        content: assistantContent,
+      });
+
+      return toolCalls.map((call) => ({
+        name: call.name,
+        args: call.args,
+        source: call,
+      }));
+    },
+    appendToolResult({ collected, call, toolResult }) {
+      collected.push({
+        type: "tool_result",
+        tool_use_id: String(call.source.id || ""),
+        content: clipText(toJsonString(toolResult), 12000),
+        is_error: Boolean(!toolResult || toolResult.ok === false),
+      });
+    },
+    flushToolResults({ messages, collected }) {
+      messages.push({
+        role: "user",
+        content: collected,
+      });
+    },
+  };
+
+  return assertTransport(transport, "anthropic-messages");
+}
+
+module.exports = {
+  createAnthropicMessagesTransport,
+};

package/src/code/providers/index.js

@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+  ...require("./transportContract"),
+  ...require("./openaiChatTransport"),
+  ...require("./anthropicMessagesTransport"),
+};

package/src/code/providers/openaiChatTransport.js

@@ -0,0 +1,98 @@
+"use strict";
+
+const { randomUUID } = require("crypto");
+const { assertTransport } = require("./transportContract");
+
+/**
+ * OpenAI-compatible chat-completions transport adapter.
+ * @param {{
+ *   resolveUrl: Function,
+ *   runTurn: Function,
+ *   normalizeToolName: Function,
+ *   normalizeToolCallArgs: Function,
+ *   toJsonString: Function,
+ *   clipText: Function,
+ * }} deps
+ */
+function createOpenAiChatTransport(deps = {}) {
+  const {
+    resolveUrl,
+    runTurn,
+    normalizeToolName,
+    normalizeToolCallArgs,
+    toJsonString,
+    clipText,
+  } = deps;
+
+  const transport = {
+    name: "openai-chat",
+    resolveUrl,
+    prepareMessages({ messages, systemPrompt, prompt }) {
+      const systemText = String(systemPrompt || "").trim();
+      const hasSystem = messages.some((entry) => String(entry.role || "").trim() === "system");
+      if (systemText && !hasSystem) {
+        messages.unshift({ role: "system", content: systemText });
+      }
+      messages.push({ role: "user", content: String(prompt || "") });
+    },
+    runTurn,
+    getToolCalls(turnResult) {
+      return Array.isArray(turnResult.toolCalls)
+        ? turnResult.toolCalls.filter((call) => call && call.function && typeof call.function === "object")
+        : [];
+    },
+    appendFinalAssistantMessage({ messages, turnResult }) {
+      const text = String(turnResult.text || "").trim();
+      if (text) {
+        messages.push({
+          role: "assistant",
+          content: text,
+        });
+      }
+    },
+    prepareToolCalls({ messages, toolCalls }) {
+      const assistantToolCalls = [];
+      for (const call of toolCalls) {
+        const callId = String(call.id || `call_${randomUUID()}`);
+        const name = normalizeToolName(call.function.name || "");
+        const args = normalizeToolCallArgs(call.function.arguments || "");
+
+        assistantToolCalls.push({
+          id: callId,
+          type: "function",
+          function: {
+            name: name || String(call.function.name || ""),
+            arguments: toJsonString(args),
+          },
+        });
+      }
+
+      if (assistantToolCalls.length === 0) return null;
+
+      messages.push({
+        role: "assistant",
+        content: null,
+        tool_calls: assistantToolCalls,
+      });
+
+      return assistantToolCalls.map((toolCall) => ({
+        name: toolCall.function.name,
+        args: normalizeToolCallArgs(toolCall.function.arguments),
+        source: toolCall,
+      }));
+    },
+    appendToolResult({ messages, call, toolResult }) {
+      messages.push({
+        role: "tool",
+        tool_call_id: call.source.id,
+        content: clipText(toJsonString(toolResult), 12000),
+      });
+    },
+  };
+
+  return assertTransport(transport, "openai-chat");
+}
+
+module.exports = {
+  createOpenAiChatTransport,
+};

package/src/code/providers/transportContract.js

@@ -0,0 +1,46 @@
+"use strict";
+
+/**
+ * Transport contract for native Agent Loop Provider adapters.
+ *
+ * Transports own wire-format conversion and turn execution only.
+ * They must not decide Plan Mode, write leases, or tool batch policy.
+ *
+ * Required methods:
+ * - resolveUrl(baseUrl) → string
+ * - prepareMessages({ messages, systemPrompt?, prompt })
+ * - runTurn(params) → Promise<turnResult>
+ * - getToolCalls(turnResult) → array
+ * - appendFinalAssistantMessage({ messages, turnResult })
+ * - prepareToolCalls({ messages, turnResult?, toolCalls }) → pendingCalls|null
+ * - appendToolResult({ messages?, collected?, call, toolResult })
+ * - flushToolResults?({ messages, collected })  // Anthropic-style batch
+ */
+
+const TRANSPORT_NAMES = Object.freeze(["openai-chat", "anthropic-messages"]);
+
+function assertTransport(transport = null, name = "") {
+  if (!transport || typeof transport !== "object") {
+    throw new Error(`missing transport${name ? `: ${name}` : ""}`);
+  }
+  const required = [
+    "resolveUrl",
+    "prepareMessages",
+    "runTurn",
+    "getToolCalls",
+    "appendFinalAssistantMessage",
+    "prepareToolCalls",
+    "appendToolResult",
+  ];
+  for (const key of required) {
+    if (typeof transport[key] !== "function") {
+      throw new Error(`transport ${name || "?"} missing ${key}`);
+    }
+  }
+  return transport;
+}
+
+module.exports = {
+  TRANSPORT_NAMES,
+  assertTransport,
+};

package/src/code/repl.js

@@ -283,6 +283,7 @@ async function runUcodeCoreAgent({
     resolveUcodeProviderModel,
     runNaturalLanguageTask,
     resumeAfterUserInteraction,
+    submitUserInteractionAnswer,
   } = require("./agent");
   const resolvedWorkspaceRoot = resolveUfooProjectRoot(workspaceRoot);
   const resolvedUcode = resolveUcodeProviderModel({
@@ -592,23 +593,12 @@ async function runUcodeCoreAgent({
 
       // Pending approval/choice/chat takes priority over nudge / new NL.
       try {
-        const {
-          hasPendingUserInteraction,
-          parseUserInteractionInput,
-          getPendingUserInteraction,
-        } = require("./context/userInteraction");
+        const { hasPendingUserInteraction } = require("./context/userInteraction");
         if (
           trimmed
           && state.executionState
           && hasPendingUserInteraction(state.executionState)
         ) {
-          const pending = getPendingUserInteraction(state.executionState);
-          const parsed = parseUserInteractionInput(pending, trimmed);
-          if (!parsed.ok) {
-            stdout.write(`${parsed.error || "Invalid reply"}\n`);
-            printPrompt(stdout);
-            return;
-          }
           chain = chain.then(async () => {
             let streamBuffer = null;
             let streamedVisible = false;
@@ -622,7 +612,7 @@ async function runUcodeCoreAgent({
             taskInFlight = true;
             let resumeResult;
             try {
-              resumeResult = await resumeAfterUserInteraction(trimmed, state, {
+              resumeResult = await submitUserInteractionAnswer(trimmed, state, {
                 onDelta: state.jsonOutput
                   ? null
                   : async (delta) => {
@@ -649,15 +639,12 @@ async function runUcodeCoreAgent({
             if (streamed && streamedVisible && resumeResult && resumeResult.streamLastChar !== "\n") {
               stdout.write("\n");
             }
-            if (resumeResult && resumeResult.waitingUserInteraction) {
-              stdout.write("Still waiting for your reply.\n");
-            } else if (!resumeResult || resumeResult.ok === false) {
+            if (!resumeResult || resumeResult.ok === false) {
               stdout.write(`Error: ${(resumeResult && resumeResult.error) || "resume failed"}\n`);
-            } else {
-              const shouldSkipSummary = Boolean(streamed && resumeResult.ok && streamedVisible);
-              if (!shouldSkipSummary && resumeResult.summary) {
-                stdout.write(`${resumeResult.summary}\n`);
-              }
+            } else if (resumeResult.shouldEchoSummary && resumeResult.echoSummaryText) {
+              stdout.write(`${resumeResult.echoSummaryText}\n`);
+            } else if (resumeResult.waitingUserInteraction) {
+              stdout.write("Still waiting for your reply.\n");
             }
             const persisted = persistSessionState(state);
             if (!state.jsonOutput && (!persisted || persisted.ok === false)) {

package/src/code/runtime/taskLoop.js

@@ -357,17 +357,28 @@ function processTaskRun(executionState = null, taskRunId = "", options = {}) {
 
 /**
  * Resume queued/running TaskRuns after process restart (executionState restored).
+ * Requeues interrupted mid-tool/model runs, releases stale leases, then advances.
  */
 function resumePersistedTaskRuns(executionState = null, options = {}) {
   const state = ensureGraphs(executionState);
+  const {
+    recoverTaskRunsAfterRestart,
+  } = require("./taskRun");
+  const { releaseStaleWriteLeases } = require("./workspaceLease");
+  const recovery = recoverTaskRunsAfterRestart(state);
+  const leases = releaseStaleWriteLeases(state, {
+    maxAgeMs: options.leaseStaleMs,
+  });
   const byId = state.taskRuns && state.taskRuns.byId ? state.taskRuns.byId : {};
   const results = [];
   for (const run of Object.values(byId)) {
     if (!run) continue;
-    if (run.status !== "queued" && run.status !== "running") continue;
+    if (run.status !== "queued" && run.status !== "running" && run.status !== "cancelling") {
+      continue;
+    }
     results.push(processTaskRun(state, run.id, options));
   }
-  return results;
+  return { recovery, leases, results };
 }
 
 module.exports = {

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;
 }
 
@@ -73,6 +111,8 @@ function createTaskRun({
     createdAt: now,
     startedAt: "",
     completedAt: "",
+    heartbeatAt: "",
+    lastWakeupId: "",
   };
 }
 
@@ -113,8 +153,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 +181,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 +194,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 +227,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 +246,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 +338,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();