u-foo 1.7.4 → 1.8.0

package/src/daemon/promptRequest.js

@@ -5,6 +5,29 @@ const {
   listControllerInboxEntries,
   consumeControllerInboxEntries,
 } = require("../report/store");
+const { isGlobalControllerProjectRoot } = require("../globalMode");
+
+function normalizeProjectRoute(route) {
+  if (!route || typeof route !== "object") return null;
+  const projectRoot = String(route.project_root || route.projectRoot || "").trim();
+  if (!projectRoot) return null;
+  return {
+    project_root: projectRoot,
+    project_name: String(route.project_name || route.projectName || "").trim(),
+    prompt: String(route.prompt || route.message || "").trim(),
+    reason: String(route.reason || "").trim(),
+  };
+}
+
+function buildRoutedProjectPayload(basePayload = {}, route = {}) {
+  const payload = basePayload && typeof basePayload === "object" ? { ...basePayload } : {};
+  payload.routed_project = {
+    project_root: String(route.project_root || ""),
+    project_name: String(route.project_name || ""),
+    reason: String(route.reason || ""),
+  };
+  return payload;
+}
 
 function buildPromptWithPrivateReports(prompt = "", reports = [], requestMeta = {}) {
   const meta = requestMeta && typeof requestMeta === "object" ? requestMeta : {};
@@ -34,6 +57,9 @@ function buildPromptWithPrivateReports(prompt = "", reports = [], requestMeta =
   lines.push(JSON.stringify(reports, null, 2));
   lines.push("");
   lines.push("Use these runtime reports when deciding reply/dispatch/ops.");
+  lines.push("Treat them as control-plane observability, not automatic downstream delivery instructions.");
+  lines.push("If report.meta.handoff.status is \"delivered\" and report.meta.needs_dispatch is not true, do not dispatch that handoff again.");
+  lines.push("Only treat a report as a controller dispatch request when report.meta.needs_dispatch is true.");
   return lines.join("\n");
 }
 
@@ -52,12 +78,61 @@ async function handlePromptRequest(options = {}) {
     handleOps,
     markPending = () => {},
     reportTaskStatus = () => {},
+    forwardProjectPrompt = null,
     log = () => {},
   } = options;
 
   log(`prompt ${String(req.text || "").slice(0, 200)}`);
+  const requestMeta = req.request_meta && typeof req.request_meta === "object" ? req.request_meta : {};
+  const isGlobalController = isGlobalControllerProjectRoot(projectRoot);
+  const forcedProjectRoot = String(requestMeta.force_project_root || "").trim();
+
+  if (isGlobalController && forcedProjectRoot) {
+    try {
+      const routed = await Promise.resolve(forwardProjectPrompt({
+        targetProjectRoot: forcedProjectRoot,
+        targetProjectName: String(requestMeta.force_project_name || "").trim(),
+        prompt: req.text || "",
+        routeReason: "forced_project_root",
+        requestMeta,
+      }));
+      if (!routed || routed.ok !== true) {
+        const error = routed && routed.error ? routed.error : "project forward failed";
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.ERROR,
+            error,
+          })}\n`,
+        );
+        return false;
+      }
+      const payload = buildRoutedProjectPayload(routed.payload || {}, {
+        project_root: routed.project_root || forcedProjectRoot,
+        project_name: routed.project_name || String(requestMeta.force_project_name || "").trim(),
+        reason: "forced_project_root",
+      });
+      socket.write(
+        `${JSON.stringify({
+          type: IPC_RESPONSE_TYPES.RESPONSE,
+          data: payload,
+          opsResults: routed.opsResults || [],
+        })}\n`,
+      );
+      return true;
+    } catch (err) {
+      socket.write(
+        `${JSON.stringify({
+          type: IPC_RESPONSE_TYPES.ERROR,
+          error: err.message || String(err),
+        })}\n`,
+      );
+      return false;
+    }
+  }
+
   const privateReports = listControllerInboxEntries(projectRoot, "ufoo-agent", { num: 100 });
-  const promptText = buildPromptWithPrivateReports(req.text || "", privateReports, req.request_meta);
+  const promptText = buildPromptWithPrivateReports(req.text || "", privateReports, requestMeta);
+  const useGlobalProjectRouter = isGlobalController;
 
   try {
     const handled = await runPromptWithAssistant({
@@ -74,6 +149,8 @@ async function handlePromptRequest(options = {}) {
       reportTaskStatus,
       maxAssistantLoops: 2,
       log,
+      ufooAgentOptions: useGlobalProjectRouter ? { routingMode: "global-router" } : {},
+      finalizeLocally: !useGlobalProjectRouter,
     });
 
     if (!handled.ok) {
@@ -87,9 +164,56 @@ async function handlePromptRequest(options = {}) {
       return false;
     }
 
+    if (useGlobalProjectRouter) {
+      const route = normalizeProjectRoute(handled.payload && handled.payload.project_route);
+      if (route) {
+        const routed = await Promise.resolve(forwardProjectPrompt({
+          targetProjectRoot: route.project_root,
+          targetProjectName: route.project_name,
+          prompt: route.prompt || req.text || "",
+          routeReason: route.reason,
+          requestMeta,
+        }));
+        if (!routed || routed.ok !== true) {
+          log(`project-forward-fail ${route.project_root} ${(routed && routed.error) || "project forward failed"}`);
+          socket.write(
+            `${JSON.stringify({
+              type: IPC_RESPONSE_TYPES.ERROR,
+              error: (routed && routed.error) || "project forward failed",
+            })}\n`,
+          );
+          return false;
+        }
+
+        consumeControllerInboxEntries(projectRoot, "ufoo-agent", privateReports);
+        const routedPayload = buildRoutedProjectPayload(routed.payload || {}, {
+          project_root: routed.project_root || route.project_root,
+          project_name: routed.project_name || route.project_name,
+          reason: route.reason,
+        });
+        log(`project-forward-ok ${route.project_root}`);
+        socket.write(
+          `${JSON.stringify({
+            type: IPC_RESPONSE_TYPES.RESPONSE,
+            data: routedPayload,
+            opsResults: routed.opsResults || [],
+          })}\n`,
+        );
+        return true;
+      }
+    }
+
     consumeControllerInboxEntries(projectRoot, "ufoo-agent", privateReports);
 
-    const payload = handled.payload || {};
+    const payload = handled.payload && typeof handled.payload === "object"
+      ? { ...handled.payload }
+      : {};
+    if (useGlobalProjectRouter) {
+      delete payload.project_route;
+      delete payload.disambiguate;
+      payload.dispatch = [];
+      payload.ops = [];
+    }
     const opsResults = handled.opsResults || [];
     log(`ok reply=${Boolean(payload.reply)} dispatch=${(payload.dispatch || []).length} ops=${(payload.ops || []).length}`);
     socket.write(

package/src/daemon/reporting.js

@@ -1,4 +1,5 @@
 const fs = require("fs");
+const EventBus = require("../bus");
 const { BUS_STATUS_PHASES } = require("../shared/eventContract");
 const {
   REPORT_PHASES,
@@ -62,6 +63,21 @@ function publishToPrivateController(projectRoot, entry) {
   appendControllerInboxEntry(projectRoot, entry.controller_id, entry);
 }
 
+async function wakePrivateController(projectRoot, entry, log = () => {}) {
+  if (!entry || entry.scope !== "private" || !entry.controller_id) return false;
+  try {
+    const eventBus = new EventBus(projectRoot);
+    await eventBus.wake(entry.controller_id, {
+      reason: `agent-report:${entry.phase}`,
+      shake: false,
+    });
+    return true;
+  } catch (err) {
+    log(`report wake skipped controller=${entry.controller_id} error=${err.message || String(err)}`);
+    return false;
+  }
+}
+
 async function recordAgentReport({
   projectRoot,
   report,
@@ -72,6 +88,7 @@ async function recordAgentReport({
   appendReport(projectRoot, entry);
   const state = updateReportState(projectRoot, entry);
   publishToPrivateController(projectRoot, entry);
+  await wakePrivateController(projectRoot, entry, log);
   const displayName = resolveAgentDisplayName(projectRoot, entry.agent_id);
   if (entry.scope !== "private") {
     onStatus(buildReportStatus(entry, displayName));
@@ -87,4 +104,5 @@ module.exports = {
   formatStatusText,
   buildReportStatus,
   publishToPrivateController,
+  wakePrivateController,
 };

package/src/daemon/soloBootstrap.js

@@ -0,0 +1,435 @@
+"use strict";
+
+const path = require("path");
+const EventBus = require("../bus");
+const { prepareUcodeBootstrap } = require("../agent/ucodeBootstrap");
+const { isMetaActive } = require("../bus/utils");
+const { getUfooPaths } = require("../ufoo/paths");
+const { loadAgentsData, saveAgentsData } = require("../ufoo/agentsStore");
+const {
+  loadPromptProfileRegistry,
+  resolvePromptProfileReference,
+} = require("../group/promptProfiles");
+const {
+  buildSoloPromptMetadata,
+  composeSoloBootstrapPrompt,
+} = require("../group/bootstrap");
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function asTrimmedString(value) {
+  return typeof value === "string" ? value.trim() : "";
+}
+
+function resolveSoloPromptProfile(projectRoot, reference = "", options = {}) {
+  const requested = String(reference || "").trim();
+  if (!requested) {
+    return { ok: true, requested_profile: "", profile: null, registry: null };
+  }
+  const registry = loadPromptProfileRegistry(projectRoot, options);
+  if (Array.isArray(registry.errors) && registry.errors.length > 0) {
+    const first = registry.errors[0];
+    return {
+      ok: false,
+      error: first && first.message ? first.message : "prompt profile registry failed to load",
+      registry,
+    };
+  }
+  const profile = resolvePromptProfileReference(registry, requested);
+  if (!profile) {
+    return {
+      ok: false,
+      error: `unknown prompt profile: ${requested}`,
+      registry,
+    };
+  }
+  return {
+    ok: true,
+    requested_profile: requested,
+    profile,
+    registry,
+  };
+}
+
+function buildSoloBootstrap({
+  nickname = "",
+  agentType = "",
+  requestedProfile = "",
+  profile = null,
+} = {}) {
+  if (!profile) {
+    return { ok: true, required: false, promptText: "", metadata: {}, profile: null };
+  }
+  const metadata = buildSoloPromptMetadata({
+    nickname,
+    agentType,
+    requestedProfile,
+    resolvedProfile: profile.id,
+    displayName: profile.display_name,
+    shortName: profile.short_name,
+    summary: profile.summary,
+    source: profile.source,
+  });
+  const promptText = composeSoloBootstrapPrompt({
+    profilePrompt: profile.prompt,
+    metadata,
+  });
+  return {
+    ok: true,
+    required: true,
+    promptText,
+    metadata,
+    profile,
+  };
+}
+
+function parseTimestampMs(value) {
+  const ms = Date.parse(String(value || ""));
+  return Number.isFinite(ms) ? ms : Number.NaN;
+}
+
+function getAgentRuntimeMeta(projectRoot, subscriberId) {
+  try {
+    const busPath = getUfooPaths(projectRoot).agentsFile;
+    const bus = loadAgentsData(busPath);
+    const meta = bus && bus.agents ? bus.agents[subscriberId] : null;
+    return meta && typeof meta === "object" ? meta : null;
+  } catch {
+    return null;
+  }
+}
+
+async function waitForSoloBootstrapReady(projectRoot, subscriberId, options = {}) {
+  const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 15000;
+  const retryDelayMs = Number.isFinite(options.retryDelayMs) ? options.retryDelayMs : 250;
+  const protectionMs = Number.isFinite(options.protectionMs) ? options.protectionMs : 3000;
+  const workingGraceMs = Number.isFinite(options.workingGraceMs) ? options.workingGraceMs : 10000;
+  const startedAt = Date.now();
+  let lastState = "";
+
+  while (Date.now() - startedAt < timeoutMs) {
+    const meta = getAgentRuntimeMeta(projectRoot, subscriberId);
+    const status = asTrimmedString(meta && meta.status).toLowerCase();
+    const state = asTrimmedString(meta && meta.activity_state).toLowerCase();
+    lastState = state || lastState;
+    if (status && status !== "active") {
+      return { ok: false, error: `agent became ${status} before bootstrap` };
+    }
+    const elapsed = Date.now() - startedAt;
+    if (state === "ready" || state === "idle" || state === "waiting_input" || state === "blocked") {
+      return { ok: true, activity_state: state };
+    }
+    if (state === "working") {
+      if (elapsed < protectionMs) {
+        await sleep(retryDelayMs);
+        continue;
+      }
+      const activitySinceMs = parseTimestampMs(meta && meta.activity_since);
+      const workingMs = Number.isFinite(activitySinceMs)
+        ? Math.max(0, Date.now() - activitySinceMs)
+        : elapsed;
+      if (workingMs >= workingGraceMs) {
+        return { ok: true, activity_state: state, degraded: true };
+      }
+    }
+    if (!state || state === "starting" || state === "running" || state === "working") {
+      await sleep(retryDelayMs);
+      continue;
+    }
+    await sleep(retryDelayMs);
+  }
+
+  return {
+    ok: false,
+    error: lastState
+      ? `agent not ready for bootstrap (last activity_state=${lastState})`
+      : "agent not ready for bootstrap",
+  };
+}
+
+async function injectSoloBootstrapPrompt(projectRoot, subscriberId, promptText, options = {}) {
+  const ready = await waitForSoloBootstrapReady(projectRoot, subscriberId, options);
+  if (!ready.ok) return ready;
+
+  const timeoutMs = Number.isFinite(options.timeoutMs) ? options.timeoutMs : 15000;
+  const retryDelayMs = Number.isFinite(options.retryDelayMs) ? options.retryDelayMs : 250;
+  const deadline = Date.now() + timeoutMs;
+  const bus = new EventBus(projectRoot);
+  let lastError = null;
+  while (Date.now() < deadline) {
+    try {
+      await bus.inject(subscriberId, promptText);
+      return { ok: true };
+    } catch (err) {
+      lastError = err;
+      await sleep(retryDelayMs);
+    }
+  }
+  return {
+    ok: false,
+    error: lastError && lastError.message ? lastError.message : `bootstrap inject failed for ${subscriberId}`,
+  };
+}
+
+function prepareSoloUcodeBootstrap(projectRoot, nickname, promptText) {
+  const safeNickname = String(nickname || "agent").replace(/[^a-zA-Z0-9._-]/g, "-");
+  const targetFile = path.join(getUfooPaths(projectRoot).agentDir, "ucode", `${safeNickname}-bootstrap.md`);
+  return prepareUcodeBootstrap({
+    projectRoot,
+    targetFile,
+    promptText,
+  });
+}
+
+function loadBusMeta(projectRoot) {
+  return loadAgentsData(getUfooPaths(projectRoot).agentsFile);
+}
+
+function isLiveAgentMeta(meta) {
+  return Boolean(meta) && isMetaActive(meta);
+}
+
+function resolveExistingAgent(projectRoot, target = "") {
+  const key = String(target || "").trim();
+  if (!key) return null;
+  const bus = loadBusMeta(projectRoot);
+  const agents = bus && bus.agents ? bus.agents : {};
+  if (isLiveAgentMeta(agents[key])) {
+    return { subscriberId: key, meta: agents[key] };
+  }
+  for (const [subscriberId, meta] of Object.entries(agents)) {
+    if (meta && meta.nickname === key && isLiveAgentMeta(meta)) {
+      return { subscriberId, meta };
+    }
+  }
+  return null;
+}
+
+function findOwningGroup(projectRoot, subscriberId = "") {
+  const targetSubscriber = asTrimmedString(subscriberId);
+  if (!targetSubscriber) return null;
+  const liveMeta = getAgentRuntimeMeta(projectRoot, targetSubscriber);
+  if (!isLiveAgentMeta(liveMeta)) return null;
+  if (asTrimmedString(liveMeta.role_owner).toLowerCase() === "solo") return null;
+  const liveNickname = asTrimmedString(liveMeta.nickname);
+  const groupsDir = getUfooPaths(projectRoot).groupsDir;
+  if (!groupsDir) return null;
+  let files = [];
+  try {
+    files = require("fs").readdirSync(groupsDir).filter((name) => name.endsWith(".json"));
+  } catch {
+    return null;
+  }
+  for (const fileName of files) {
+    try {
+      const filePath = path.join(groupsDir, fileName);
+      const runtime = JSON.parse(require("fs").readFileSync(filePath, "utf8"));
+      if (!runtime || runtime.status !== "active" || !Array.isArray(runtime.members)) continue;
+      const found = runtime.members.find((member) =>
+        member
+        && asTrimmedString(member.subscriber_id) === targetSubscriber
+        && (member.status === "active" || member.status === "reused")
+        && asTrimmedString(member.nickname)
+        && (!liveNickname || asTrimmedString(member.nickname) === liveNickname)
+      );
+      if (found) {
+        return {
+          group_id: String(runtime.group_id || "").trim(),
+          template_alias: String(runtime.template_alias || "").trim(),
+          nickname: String(found.nickname || "").trim(),
+        };
+      }
+    } catch {
+      // ignore malformed runtime
+    }
+  }
+  return null;
+}
+
+function pickLaunchSubscriber(launchResult = {}, fallbackTarget = "") {
+  if (launchResult && Array.isArray(launchResult.subscriber_ids) && launchResult.subscriber_ids.length > 0) {
+    return asTrimmedString(launchResult.subscriber_ids[0]);
+  }
+  if (launchResult && launchResult.agent_id) {
+    return asTrimmedString(launchResult.agent_id);
+  }
+  return asTrimmedString(fallbackTarget);
+}
+
+function shouldRollbackRoleAssignmentLaunch(launchResult = {}) {
+  return Boolean(launchResult && launchResult.ok !== false && launchResult.skipped !== true);
+}
+
+async function rollbackLaunchAfterRoleAssignmentFailure(
+  projectRoot,
+  launchResult,
+  fallbackTarget,
+  handleOps,
+  processManager = null
+) {
+  if (!shouldRollbackRoleAssignmentLaunch(launchResult)) {
+    return { ok: true, skipped: true, rolled_back: false, target: "" };
+  }
+  if (typeof handleOps !== "function") {
+    return { ok: false, rolled_back: false, target: "", error: "handleOps is required for rollback" };
+  }
+  const target = pickLaunchSubscriber(launchResult, fallbackTarget);
+  if (!target) {
+    return { ok: false, rolled_back: false, target: "", error: "missing subscriber_id for rollback" };
+  }
+  const opsResults = await handleOps(projectRoot, [{ action: "close", agent_id: target }], processManager);
+  const closeResult = Array.isArray(opsResults)
+    ? opsResults.find((entry) => entry && entry.action === "close")
+    : null;
+  if (closeResult && closeResult.ok !== false) {
+    return { ok: true, skipped: false, rolled_back: true, target };
+  }
+  return {
+    ok: false,
+    skipped: false,
+    rolled_back: false,
+    target,
+    error: closeResult && closeResult.error ? closeResult.error : "close failed",
+  };
+}
+
+function persistSoloRoleMetadata(projectRoot, subscriberId, payload = {}) {
+  const filePath = getUfooPaths(projectRoot).agentsFile;
+  const bus = loadAgentsData(filePath);
+  const meta = bus.agents && bus.agents[subscriberId];
+  if (!meta) return false;
+  bus.agents[subscriberId] = {
+    ...meta,
+    bootstrap_kind: "solo",
+    role_owner: "solo",
+    requested_profile: String(payload.requested_profile || "").trim(),
+    resolved_profile: String(payload.resolved_profile || "").trim(),
+    bootstrap_fingerprint: String(payload.bootstrap_fingerprint || "").trim(),
+    bootstrapped_subscriber_id: String(payload.bootstrapped_subscriber_id || subscriberId).trim(),
+    role_assigned_at: new Date().toISOString(),
+  };
+  saveAgentsData(filePath, bus);
+  return true;
+}
+
+function buildSoloBootstrapFingerprint({ subscriberId = "", requestedProfile = "", resolvedProfile = "", promptText = "" } = {}) {
+  return require("crypto")
+    .createHash("sha256")
+    .update(JSON.stringify({
+      subscriber_id: String(subscriberId || ""),
+      requested_profile: String(requestedProfile || ""),
+      resolved_profile: String(resolvedProfile || ""),
+      prompt: String(promptText || ""),
+    }))
+    .digest("hex");
+}
+
+function isSameSoloAssignment(meta = {}, subscriberId = "", requestedProfile = "", resolvedProfile = "", promptText = "") {
+  const currentOwner = String(meta.role_owner || "").trim();
+  const currentKind = String(meta.bootstrap_kind || "").trim();
+  const currentFingerprint = String(meta.bootstrap_fingerprint || "").trim();
+  const nextFingerprint = buildSoloBootstrapFingerprint({
+    subscriberId,
+    requestedProfile,
+    resolvedProfile,
+    promptText,
+  });
+  return currentOwner === "solo"
+    && currentKind === "solo"
+    && currentFingerprint
+    && currentFingerprint === nextFingerprint;
+}
+
+async function assignSoloRoleToExistingAgent(projectRoot, target, profileReference, options = {}) {
+  const resolvedTarget = resolveExistingAgent(projectRoot, target);
+  if (!resolvedTarget) {
+    return { ok: false, error: `agent not found: ${target}` };
+  }
+  const ownership = findOwningGroup(projectRoot, resolvedTarget.subscriberId);
+  if (ownership) {
+    return {
+      ok: false,
+      error: `agent is group-owned by ${ownership.group_id || ownership.template_alias || "active-group"}`,
+      group: ownership,
+      subscriber_id: resolvedTarget.subscriberId,
+    };
+  }
+
+  const resolvedProfile = resolveSoloPromptProfile(projectRoot, profileReference, options.promptProfilesOptions || {});
+  if (!resolvedProfile.ok) return resolvedProfile;
+  const built = buildSoloBootstrap({
+    nickname: resolvedTarget.meta.nickname || resolvedTarget.subscriberId,
+    agentType: resolvedTarget.meta.agent_type || "",
+    requestedProfile: resolvedProfile.requested_profile,
+    profile: resolvedProfile.profile,
+  });
+  if (!built.required) {
+    return { ok: false, error: "prompt profile is required" };
+  }
+
+  if (isSameSoloAssignment(
+    resolvedTarget.meta,
+    resolvedTarget.subscriberId,
+    resolvedProfile.requested_profile,
+    resolvedProfile.profile.id,
+    built.promptText,
+  )) {
+    return {
+      ok: true,
+      skipped: true,
+      subscriber_id: resolvedTarget.subscriberId,
+      requested_profile: resolvedProfile.requested_profile,
+      resolved_profile: resolvedProfile.profile.id,
+    };
+  }
+
+  const injected = await injectSoloBootstrapPrompt(
+    projectRoot,
+    resolvedTarget.subscriberId,
+    built.promptText,
+    options.bootstrapOptions || {},
+  );
+  if (!injected.ok) {
+    return {
+      ok: false,
+      error: injected.error || "solo bootstrap inject failed",
+      subscriber_id: resolvedTarget.subscriberId,
+    };
+  }
+
+  const fingerprint = buildSoloBootstrapFingerprint({
+    subscriberId: resolvedTarget.subscriberId,
+    requestedProfile: resolvedProfile.requested_profile,
+    resolvedProfile: resolvedProfile.profile.id,
+    promptText: built.promptText,
+  });
+  persistSoloRoleMetadata(projectRoot, resolvedTarget.subscriberId, {
+    requested_profile: resolvedProfile.requested_profile,
+    resolved_profile: resolvedProfile.profile.id,
+    bootstrap_fingerprint: fingerprint,
+    bootstrapped_subscriber_id: resolvedTarget.subscriberId,
+  });
+
+  return {
+    ok: true,
+    subscriber_id: resolvedTarget.subscriberId,
+    requested_profile: resolvedProfile.requested_profile,
+    resolved_profile: resolvedProfile.profile.id,
+  };
+}
+
+module.exports = {
+  resolveSoloPromptProfile,
+  buildSoloBootstrap,
+  waitForSoloBootstrapReady,
+  injectSoloBootstrapPrompt,
+  prepareSoloUcodeBootstrap,
+  resolveExistingAgent,
+  findOwningGroup,
+  persistSoloRoleMetadata,
+  buildSoloBootstrapFingerprint,
+  rollbackLaunchAfterRoleAssignmentFailure,
+  assignSoloRoleToExistingAgent,
+};

package/src/daemon/status.js

@@ -2,7 +2,7 @@ const fs = require("fs");
 const path = require("path");
 const { getUfooPaths } = require("../ufoo/paths");
 const { isMetaActive } = require("../bus/utils");
-const { readReportSummary } = require("../report/store");
+const { readReportSummary, countControllerInboxEntries } = require("../report/store");
 
 function readBus(projectRoot) {
   const busPath = getUfooPaths(projectRoot).agentsFile;
@@ -72,6 +72,8 @@ function normalizeCronTasks(raw = []) {
     onceAt: String(task && task.onceAt ? task.onceAt : ""),
     targets: Array.isArray(task && task.targets) ? task.targets.slice() : [],
     prompt: String(task && task.prompt ? task.prompt : ""),
+    title: String(task && task.title ? task.title : ""),
+    label: String(task && task.label ? task.label : ""),
     summary: String(task && task.summary ? task.summary : ""),
     createdAt: Number(task && task.createdAt ? task.createdAt : 0) || 0,
     lastRunAt: Number(task && task.lastRunAt ? task.lastRunAt : 0) || 0,
@@ -130,6 +132,7 @@ function buildStatus(projectRoot, options = {}) {
   const decisions = readDecisions(projectRoot);
   const unread = readUnread(projectRoot);
   const reports = readReportSummary(projectRoot);
+  const controllerPendingTotal = countControllerInboxEntries(projectRoot, "ufoo-agent");
   const groups = readGroups(projectRoot);
   const subscribers = bus ? Object.keys(bus.agents || {}) : [];
   const cronTasks = normalizeCronTasks(options.cronTasks || []);
@@ -174,6 +177,9 @@ function buildStatus(projectRoot, options = {}) {
     unread,
     decisions,
     reports,
+    controller: {
+      pending_total: controllerPendingTotal,
+    },
     cron: {
       count: cronTasks.length,
       tasks: cronTasks,