u-foo 1.9.8 → 2.2.0

package/src/controller/shadowGuard.js

@@ -0,0 +1,280 @@
+"use strict";
+
+const crypto = require("crypto");
+const fs = require("fs");
+const path = require("path");
+
+const { getUfooPaths } = require("../ufoo/paths");
+
+const DEFAULT_SHADOW_SAMPLING_RATE = 0.1;
+const DEFAULT_SHADOW_DAILY_INPUT_TOKEN_LIMIT = 50000;
+const DEFAULT_SHADOW_DAILY_OUTPUT_TOKEN_LIMIT = 10000;
+
+const TIER2_MOCK_TOOL_NAMES = Object.freeze([
+  "dispatch_message",
+  "launch_agent",
+  "rename_agent",
+  "close_agent",
+  "manage_cron",
+]);
+
+function hashMessageId(messageId) {
+  const raw = String(messageId || "").trim();
+  if (!raw) return 0;
+  const digest = crypto.createHash("sha1").update(raw).digest();
+  return digest.readUInt32BE(0);
+}
+
+function shouldSampleShadow({ messageId = "", samplingRate = DEFAULT_SHADOW_SAMPLING_RATE } = {}) {
+  const rate = Number(samplingRate);
+  if (!Number.isFinite(rate) || rate <= 0) return { sampled: false, rate: 0 };
+  if (rate >= 1) return { sampled: true, rate: 1 };
+  const bucket = hashMessageId(messageId) / 0xffffffff;
+  return { sampled: bucket < rate, rate };
+}
+
+function getShadowBudgetPath(projectRoot, now = new Date()) {
+  const { ufooDir } = getUfooPaths(projectRoot);
+  const stamp = now.toISOString().slice(0, 10);
+  return path.join(ufooDir, "shadow", `budget-${stamp}.json`);
+}
+
+function readShadowBudgetState(file) {
+  try {
+    const raw = fs.readFileSync(file, "utf8");
+    const parsed = JSON.parse(raw);
+    return {
+      input_tokens_used: Number(parsed.input_tokens_used) || 0,
+      output_tokens_used: Number(parsed.output_tokens_used) || 0,
+      tripped: Boolean(parsed.tripped),
+      tripped_reason: String(parsed.tripped_reason || ""),
+    };
+  } catch {
+    return { input_tokens_used: 0, output_tokens_used: 0, tripped: false, tripped_reason: "" };
+  }
+}
+
+function writeShadowBudgetState(file, state) {
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(state, null, 2));
+}
+
+function createShadowBudgetBreaker({
+  projectRoot,
+  inputLimit = DEFAULT_SHADOW_DAILY_INPUT_TOKEN_LIMIT,
+  outputLimit = DEFAULT_SHADOW_DAILY_OUTPUT_TOKEN_LIMIT,
+  now = () => new Date(),
+} = {}) {
+  const resolveFile = () => getShadowBudgetPath(projectRoot, now());
+
+  return {
+    check() {
+      const file = resolveFile();
+      const state = readShadowBudgetState(file);
+      if (state.tripped) {
+        return { allowed: false, reason: state.tripped_reason || "shadow_budget_tripped", state };
+      }
+      if (state.input_tokens_used >= inputLimit) {
+        return { allowed: false, reason: "shadow_input_budget_exceeded", state };
+      }
+      if (state.output_tokens_used >= outputLimit) {
+        return { allowed: false, reason: "shadow_output_budget_exceeded", state };
+      }
+      return { allowed: true, state };
+    },
+    record({ inputTokens = 0, outputTokens = 0, tripped = false, trippedReason = "" } = {}) {
+      const file = resolveFile();
+      const state = readShadowBudgetState(file);
+      state.input_tokens_used += Math.max(0, Number(inputTokens) || 0);
+      state.output_tokens_used += Math.max(0, Number(outputTokens) || 0);
+      if (tripped) {
+        state.tripped = true;
+        state.tripped_reason = String(trippedReason || "shadow_budget_tripped");
+      } else if (state.input_tokens_used >= inputLimit) {
+        state.tripped = true;
+        state.tripped_reason = "shadow_input_budget_exceeded";
+      } else if (state.output_tokens_used >= outputLimit) {
+        state.tripped = true;
+        state.tripped_reason = "shadow_output_budget_exceeded";
+      }
+      writeShadowBudgetState(file, state);
+      return state;
+    },
+    tripForProviderRateLimit(reason = "shadow_provider_rate_limit") {
+      const file = resolveFile();
+      const state = readShadowBudgetState(file);
+      state.tripped = true;
+      state.tripped_reason = reason;
+      writeShadowBudgetState(file, state);
+      return state;
+    },
+  };
+}
+
+function snapshotDirectory(rootDir) {
+  const entries = [];
+  if (!rootDir || !fs.existsSync(rootDir)) {
+    return { root: rootDir, entries };
+  }
+
+  const walk = (dir) => {
+    let list;
+    try {
+      list = fs.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of list) {
+      const abs = path.join(dir, entry.name);
+      if (entry.isDirectory()) {
+        walk(abs);
+        continue;
+      }
+      try {
+        const stat = fs.statSync(abs);
+        entries.push({
+          path: abs,
+          size: stat.size,
+          ino: stat.ino,
+          mtime_ms: Math.floor(stat.mtimeMs),
+        });
+      } catch {
+        // ignore transient errors
+      }
+    }
+  };
+
+  walk(rootDir);
+  entries.sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
+  return { root: rootDir, entries };
+}
+
+function diffSnapshots(before = { entries: [] }, after = { entries: [] }) {
+  const diffs = [];
+  const beforeMap = new Map();
+  for (const item of before.entries || []) beforeMap.set(item.path, item);
+  const seen = new Set();
+
+  for (const item of after.entries || []) {
+    seen.add(item.path);
+    const prior = beforeMap.get(item.path);
+    if (!prior) {
+      diffs.push({ path: item.path, kind: "added" });
+      continue;
+    }
+    if (prior.size !== item.size || prior.ino !== item.ino) {
+      diffs.push({ path: item.path, kind: "modified" });
+    }
+  }
+
+  for (const item of before.entries || []) {
+    if (!seen.has(item.path)) {
+      diffs.push({ path: item.path, kind: "removed" });
+    }
+  }
+
+  return diffs;
+}
+
+function resolveBusQueueRoot(projectRoot) {
+  const { ufooDir } = getUfooPaths(projectRoot);
+  return path.join(ufooDir, "bus", "queues");
+}
+
+function resolveMemoryRoot(projectRoot) {
+  const { ufooDir } = getUfooPaths(projectRoot);
+  return path.join(ufooDir, "memory");
+}
+
+function buildTier2ToolExecutor(ctx = {}) {
+  const invocations = [];
+  return {
+    invocations,
+    async execute(toolCall = {}) {
+      const name = String(toolCall.name || "").trim();
+      invocations.push({ name, arguments: toolCall.arguments || {} });
+      if (TIER2_MOCK_TOOL_NAMES.includes(name)) {
+        return {
+          ok: true,
+          mocked: true,
+          shadow_only: true,
+          name,
+          result: { mocked: true, shadow_only: true },
+        };
+      }
+      if (typeof ctx.fallback === "function") {
+        return ctx.fallback(toolCall);
+      }
+      return {
+        ok: false,
+        error: { code: "shadow_only_tool_unavailable", message: `tool ${name} disabled in shadow mode` },
+      };
+    },
+  };
+}
+
+function createShadowGuard({ projectRoot, now = () => new Date() } = {}) {
+  const busQueueRoot = resolveBusQueueRoot(projectRoot);
+  const memoryRoot = resolveMemoryRoot(projectRoot);
+  const tier2 = buildTier2ToolExecutor();
+
+  function takeSnapshot() {
+    return {
+      ts: now().toISOString(),
+      bus_queue: snapshotDirectory(busQueueRoot),
+      memory: snapshotDirectory(memoryRoot),
+    };
+  }
+
+  function assertNoSideEffects(beforeSnapshot, afterSnapshot = takeSnapshot()) {
+    const busDiff = diffSnapshots(beforeSnapshot.bus_queue, afterSnapshot.bus_queue);
+    const memoryDiff = diffSnapshots(beforeSnapshot.memory, afterSnapshot.memory);
+    const violations = [
+      ...busDiff.map((d) => ({ scope: "bus_queue", ...d })),
+      ...memoryDiff.map((d) => ({ scope: "memory", ...d })),
+    ];
+    return {
+      ok: violations.length === 0,
+      violations,
+    };
+  }
+
+  function buildNoOpExecutors() {
+    return {
+      dispatchMessages: async () => undefined,
+      handleOps: async () => [],
+      ackBus: async () => 0,
+      markPending: () => {},
+      tier2ToolExecutor: tier2,
+    };
+  }
+
+  return {
+    projectRoot,
+    busQueueRoot,
+    memoryRoot,
+    takeSnapshot,
+    assertNoSideEffects,
+    buildNoOpExecutors,
+    tier2ToolInvocations: () => tier2.invocations.slice(),
+  };
+}
+
+module.exports = {
+  DEFAULT_SHADOW_DAILY_INPUT_TOKEN_LIMIT,
+  DEFAULT_SHADOW_DAILY_OUTPUT_TOKEN_LIMIT,
+  DEFAULT_SHADOW_SAMPLING_RATE,
+  TIER2_MOCK_TOOL_NAMES,
+  buildTier2ToolExecutor,
+  createShadowBudgetBreaker,
+  createShadowGuard,
+  diffSnapshots,
+  getShadowBudgetPath,
+  hashMessageId,
+  readShadowBudgetState,
+  resolveBusQueueRoot,
+  resolveMemoryRoot,
+  shouldSampleShadow,
+  snapshotDirectory,
+  writeShadowBudgetState,
+};

package/src/daemon/index.js

@@ -2,7 +2,7 @@ const fs = require("fs");
 const path = require("path");
 const net = require("net");
 const { spawn, spawnSync } = require("child_process");
-const { runUfooAgent } = require("../agent/ufooAgent");
+const { runUfooAgent, runUfooRouteAgent } = require("../agent/ufooAgent");
 const { launchAgent, closeAgent, getRecoverableAgents, resumeAgents } = require("./ops");
 const { buildStatus } = require("./status");
 const EventBus = require("../bus");
@@ -18,7 +18,6 @@ const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonCronController } = require("./cronOps");
 const { createGroupOrchestrator } = require("./groupOrchestrator");
 const { normalizeFormat, renderGroupDiagramFromTemplate, renderGroupDiagramFromRuntime } = require("../group/diagram");
-const { runAssistantTask } = require("../assistant/bridge");
 const { runPromptWithAssistant } = require("./promptLoop");
 const { handlePromptRequest } = require("./promptRequest");
 const { recordAgentReport } = require("./reporting");
@@ -1013,7 +1012,7 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
         processManager,
         runPromptWithAssistant,
         runUfooAgent,
-        runAssistantTask,
+        runUfooRouteAgent,
         dispatchMessages,
         handleOps,
         markPending: (target) => busBridge.markPending(target),

package/src/daemon/promptLoop.js

@@ -1,22 +1,3 @@
-function buildAssistantContinuationPrompt({
-  originalPrompt,
-  previousReply,
-  reports,
-}) {
-  const lines = [];
-  lines.push(`User: ${originalPrompt}`);
-  if (previousReply) {
-    lines.push("");
-    lines.push(`Your previous reply draft: ${previousReply}`);
-  }
-  lines.push("");
-  lines.push("Assistant execution reports (JSON):");
-  lines.push(JSON.stringify(reports, null, 2));
-  lines.push("");
-  lines.push("Using these reports, return the final JSON response.");
-  return lines.join("\n");
-}
-
 function normalizePayload(payload) {
   if (!payload || typeof payload !== "object") {
     return { reply: "", dispatch: [], ops: [] };
@@ -29,88 +10,27 @@ function normalizePayload(payload) {
   };
 }
 
-function annotateAssistantFailureFallback(payload, assistantResult) {
-  if (!payload || typeof payload !== "object") return payload;
-  const dispatchCount = Array.isArray(payload.dispatch) ? payload.dispatch.length : 0;
-  const opsCount = Array.isArray(payload.ops) ? payload.ops.length : 0;
-  if (dispatchCount > 0 || opsCount > 0) return payload;
-
-  const error = assistantResult && typeof assistantResult.error === "string" && assistantResult.error
-    ? assistantResult.error
-    : "assistant task failed";
-  const note = `Assistant execution failed: ${error}. No action was applied.`;
-  const reply = typeof payload.reply === "string" && payload.reply
-    ? `${payload.reply}\n${note}`
-    : note;
-  return {
-    ...payload,
-    reply,
-  };
-}
-
-function extractAssistantCall(payload) {
+function stripAssistantCall(payload) {
   if (!payload || typeof payload !== "object") {
-    return { assistantCall: null, ops: [] };
+    return { reply: "", dispatch: [], ops: [] };
   }
 
   const ops = Array.isArray(payload.ops) ? payload.ops : [];
-  let assistantCall = payload.assistant_call || null;
   const normalOps = [];
 
   for (const op of ops) {
     if (op && op.action === "assistant_call") {
-      if (!assistantCall) assistantCall = op;
       continue;
     }
     if (op) normalOps.push(op);
   }
 
-  return { assistantCall, ops: normalOps };
-}
-
-function normalizeAssistantCall(call) {
-  if (!call) return null;
-  if (typeof call === "string") {
-    return { task: call, kind: "mixed", context: "", expect: "" };
-  }
-  if (typeof call !== "object") return null;
-  const task = typeof call.task === "string" ? call.task : "";
-  if (!task) return null;
-  return {
-    task,
-    kind: typeof call.kind === "string" ? call.kind : "mixed",
-    context: typeof call.context === "string" ? call.context : "",
-    expect: typeof call.expect === "string" ? call.expect : "",
-    provider: typeof call.provider === "string" ? call.provider : "",
-    model: typeof call.model === "string" ? call.model : "",
-    timeoutMs: Number.isFinite(call.timeout_ms) ? call.timeout_ms : null,
+  const nextPayload = {
+    ...normalizePayload(payload),
+    ops: normalOps,
   };
-}
-
-function buildAssistantReport(call, result) {
-  return {
-    kind: call.kind,
-    task: call.task,
-    ok: result && result.ok !== false,
-    summary: result && typeof result.summary === "string" ? result.summary : "",
-    error: result && typeof result.error === "string" ? result.error : "",
-    artifacts: result && Array.isArray(result.artifacts) ? result.artifacts : [],
-    logs: result && Array.isArray(result.logs) ? result.logs : [],
-    metrics: result && typeof result.metrics === "object" ? result.metrics : {},
-  };
-}
-
-function createAssistantTaskId() {
-  return `assistant-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-
-async function emitAssistantReport(reportTaskStatus, payload) {
-  if (typeof reportTaskStatus !== "function") return;
-  try {
-    await reportTaskStatus(payload);
-  } catch {
-    // best effort: reporting must not break prompt flow
-  }
+  delete nextPayload.assistant_call;
+  return nextPayload;
 }
 
 async function finalizePromptRun({
@@ -153,22 +73,24 @@ async function runPromptWithAssistant({
   model,
   processManager = null,
   runUfooAgent,
-  runAssistantTask,
+  runPromptWithControllerLoop = null,
   dispatchMessages,
   handleOps,
   markPending = () => {},
-  reportTaskStatus = () => {},
-  maxAssistantLoops = 2,
-  log = () => {},
   ufooAgentOptions = {},
   finalizeLocally = true,
+  loopRuntime = null,
 }) {
+  const agentOptions = {
+    ...(ufooAgentOptions && typeof ufooAgentOptions === "object" ? ufooAgentOptions : {}),
+  };
+
   const firstResult = await runUfooAgent({
     projectRoot,
     prompt: prompt || "",
     provider,
     model,
-    ...ufooAgentOptions,
+    ...agentOptions,
   });
 
   if (!firstResult || !firstResult.ok) {
@@ -178,144 +100,35 @@ async function runPromptWithAssistant({
     };
   }
 
-  const firstPayload = normalizePayload(firstResult.payload);
-  const extractedFirst = extractAssistantCall(firstPayload);
-  const assistantCall = normalizeAssistantCall(extractedFirst.assistantCall);
-  const basePayload = {
-    ...firstPayload,
-    ops: extractedFirst.ops,
-  };
-  delete basePayload.assistant_call;
-
-  if (!assistantCall || maxAssistantLoops < 1) {
-    return finalizePromptRun({
+  const firstPayload = stripAssistantCall(firstResult.payload);
+  const shouldUpgradeToLoop = Boolean(
+    loopRuntime
+      && loopRuntime.enabled
+      && firstPayload
+      && firstPayload.upgrade_to_loop_router === true
+      && typeof runPromptWithControllerLoop === "function"
+  );
+
+  if (shouldUpgradeToLoop) {
+    return runPromptWithControllerLoop({
       projectRoot,
-      payload: basePayload,
+      prompt: prompt || "",
+      provider,
+      model,
       processManager,
+      runUfooAgent,
       dispatchMessages,
       handleOps,
       markPending,
+      ufooAgentOptions,
       finalizeLocally,
+      loopRuntime,
     });
   }
 
-  const assistantTaskId = createAssistantTaskId();
-  await emitAssistantReport(reportTaskStatus, {
-    phase: "start",
-    source: "assistant",
-    agent_id: "ufoo-assistant-agent",
-    scope: "private",
-    controller_id: "ufoo-agent",
-    task_id: assistantTaskId,
-    message: assistantCall.task,
-    summary: "",
-    error: "",
-    ok: true,
-    meta: {
-      kind: assistantCall.kind,
-      provider: assistantCall.provider || provider || "",
-      model: assistantCall.model || model || "",
-    },
-  });
-
-  let assistantResult;
-  try {
-    assistantResult = await runAssistantTask({
-      projectRoot,
-      provider: assistantCall.provider || "",
-      fallbackProvider: provider,
-      model: assistantCall.model || model,
-      task: assistantCall.task,
-      kind: assistantCall.kind,
-      context: assistantCall.context,
-      expect: assistantCall.expect,
-      timeoutMs: assistantCall.timeoutMs || undefined,
-    });
-  } catch (err) {
-    assistantResult = {
-      ok: false,
-      summary: "",
-      artifacts: [],
-      logs: [],
-      error: err && err.message ? err.message : "assistant task failed",
-      metrics: {},
-    };
-  }
-
-  await emitAssistantReport(reportTaskStatus, {
-    phase: assistantResult && assistantResult.ok === false ? "error" : "done",
-    source: "assistant",
-    agent_id: "ufoo-assistant-agent",
-    scope: "private",
-    controller_id: "ufoo-agent",
-    task_id: assistantTaskId,
-    message: assistantCall.task,
-    summary: assistantResult && typeof assistantResult.summary === "string" ? assistantResult.summary : "",
-    error: assistantResult && typeof assistantResult.error === "string" ? assistantResult.error : "",
-    ok: assistantResult && assistantResult.ok !== false,
-    meta: {
-      kind: assistantCall.kind,
-      provider: assistantCall.provider || provider || "",
-      model: assistantCall.model || model || "",
-      metrics: assistantResult && assistantResult.metrics && typeof assistantResult.metrics === "object"
-        ? assistantResult.metrics
-        : {},
-    },
-  });
-
-  if (!assistantResult || assistantResult.ok === false) {
-    log("assistant-loop fallback to round1 payload");
-    const fallbackPayload = annotateAssistantFailureFallback(basePayload, assistantResult);
-    return finalizePromptRun({
-      projectRoot,
-      payload: fallbackPayload,
-      processManager,
-      dispatchMessages,
-      handleOps,
-      markPending,
-    });
-  }
-
-  const reports = [buildAssistantReport(assistantCall, assistantResult)];
-  const continuationPrompt = buildAssistantContinuationPrompt({
-    originalPrompt: prompt || "",
-    previousReply: basePayload.reply || "",
-    reports,
-  });
-
-  const secondResult = await runUfooAgent({
-    projectRoot,
-    prompt: continuationPrompt,
-    provider,
-    model,
-    ...ufooAgentOptions,
-  });
-
-  if (!secondResult || !secondResult.ok) {
-    log("assistant-loop fallback to round1 payload (round2 failed)");
-    return finalizePromptRun({
-      projectRoot,
-      payload: basePayload,
-      processManager,
-      dispatchMessages,
-      handleOps,
-      markPending,
-      finalizeLocally,
-    });
-  }
-
-  const secondPayload = normalizePayload(secondResult.payload);
-  const extractedSecond = extractAssistantCall(secondPayload);
-  const finalPayload = {
-    ...secondPayload,
-    ops: extractedSecond.ops,
-    assistant: { runs: reports },
-  };
-  delete finalPayload.assistant_call;
-
   return finalizePromptRun({
     projectRoot,
-    payload: finalPayload,
+    payload: firstPayload,
     processManager,
     dispatchMessages,
     handleOps,
@@ -326,10 +139,6 @@ async function runPromptWithAssistant({
 
 module.exports = {
   runPromptWithAssistant,
-  buildAssistantContinuationPrompt,
   normalizePayload,
-  annotateAssistantFailureFallback,
-  extractAssistantCall,
-  normalizeAssistantCall,
-  buildAssistantReport,
+  stripAssistantCall,
 };