u-foo 2.3.32 → 2.4.0

package/src/{daemon → runtime/daemon}/ops.js

@@ -1,10 +1,10 @@
 const { spawn, spawnSync } = require("child_process");
 const fs = require("fs");
 const path = require("path");
-const { loadConfig } = require("../config");
-const { getUfooPaths } = require("../ufoo/paths");
-const { loadAgentsData, saveAgentsData } = require("../ufoo/agentsStore");
-const { isAgentPidAlive, getTtyProcessInfo } = require("../bus/utils");
+const { loadConfig } = require("../../config");
+const { getUfooPaths } = require("../../coordination/state/paths");
+const { loadAgentsData, saveAgentsData } = require("../../coordination/state/agentsStore");
+const { isAgentPidAlive, getTtyProcessInfo } = require("../../coordination/bus/utils");
 const { isITerm2 } = require("../terminal/detect");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const {
@@ -14,13 +14,14 @@ const {
 const {
   createSession: createHostSession,
 } = require("../terminal/adapters/hostAdapter");
-const { resolveDefaultManualBootstrap } = require("../agent/defaultBootstrap");
-const { detectLaunchEnvironment } = require("../agent/launchEnvironment");
+const { resolveDefaultManualBootstrap } = require("../../agents/prompts/defaultBootstrap");
+const { detectLaunchEnvironment } = require("../../agents/launch/launchEnvironment");
 
 function normalizeLaunchAgent(agent = "") {
   const value = String(agent || "").trim().toLowerCase();
   if (value === "codex") return "codex";
   if (value === "claude" || value === "claude-code") return "claude";
+  if (value === "agy" || value === "antigravity") return "agy";
   if (value === "ufoo" || value === "ucode" || value === "ufoo-code") return "ufoo";
   return "";
 }
@@ -28,6 +29,7 @@ function normalizeLaunchAgent(agent = "") {
 function toBusAgentType(agent = "") {
   if (agent === "codex") return "codex";
   if (agent === "claude") return "claude-code";
+  if (agent === "agy") return "agy";
   if (agent === "ufoo") return "ufoo-code";
   return "";
 }
@@ -35,6 +37,7 @@ function toBusAgentType(agent = "") {
 function toTerminalBinary(agent = "") {
   if (agent === "codex") return "ucodex";
   if (agent === "claude") return "uclaude";
+  if (agent === "agy") return "uagy";
   if (agent === "ufoo") return "ucode";
   return "";
 }
@@ -42,6 +45,7 @@ function toTerminalBinary(agent = "") {
 function toTmuxBinary(agent = "") {
   if (agent === "codex") return "ucodex";
   if (agent === "claude") return "uclaude";
+  if (agent === "agy") return "uagy";
   if (agent === "ufoo") return "ucode";
   return "";
 }
@@ -84,7 +88,7 @@ function applyDefaultManagedBootstrap(projectRoot, normalizedAgent, args = [], e
 }
 
 function resolveUfooRunnerPath() {
-  return path.resolve(__dirname, "../../bin/ufoo.js");
+  return path.resolve(__dirname, "../../../bin/ufoo.js");
 }
 
 function normalizeLaunchScope(value, fallback = "inplace") {
@@ -165,7 +169,7 @@ function resolveNativeTerminalApp(options = {}) {
 
 function resolveConfiguredLaunchMode(configuredMode = "", options = {}) {
   const mode = normalizeOptionalString(configuredMode);
-  if (mode === "internal" || mode === "internal-pty" || mode === "tmux" || mode === "terminal" || mode === "host") {
+  if (mode === "internal" || mode === "tmux" || mode === "terminal" || mode === "host") {
     return mode;
   }
   // Auto mode: defer to the unified detector. Daemon ops differs from the
@@ -462,8 +466,8 @@ function buildResumeCommand(projectRoot, agent, sessionId) {
   }
   const args = buildResumeArgs(agent, sessionId);
   const argText = args.length > 0 ? ` ${args.map(shellEscape).join(" ")}` : "";
-  const skipProbeEnv = "UFOO_SKIP_SESSION_PROBE=1 ";
-  return `cd ${shellEscape(projectRoot)} && ${skipProbeEnv}${binary}${argText}`;
+  const skipSessionResolveEnv = "UFOO_SKIP_SESSION_RESOLVE=1 ";
+  return `cd ${shellEscape(projectRoot)} && ${skipSessionResolveEnv}${binary}${argText}`;
 }
 
 async function tryReuseTerminal(projectRoot, subscriberId, meta, agent, sessionId) {
@@ -474,7 +478,7 @@ async function tryReuseTerminal(projectRoot, subscriberId, meta, agent, sessionI
   const baseCmd = buildResumeCommand(projectRoot, agent, sessionId);
   const command = titleCmd ? `${titleCmd} && ${baseCmd}` : baseCmd;
   try {
-    const EventBus = require("../bus");
+    const EventBus = require("../../coordination/bus");
     const bus = new EventBus(projectRoot);
     bus.ensureBus();
     await bus.inject(subscriberId, command);
@@ -541,7 +545,6 @@ async function spawnManagedHostAgent(
   }
 
   const hostContext = resolveHostLaunchContext(hostOptions);
-  const requireActivityMonitor = hostContext.requireActivityMonitor === true;
   if (!hostContext.hostDaemonSock) {
     throw new Error("host launch requires UFOO_HOST_DAEMON_SOCK");
   }
@@ -555,7 +558,7 @@ async function spawnManagedHostAgent(
 
   // Pre-register subscriber on the bus so waitForNewSubscriber resolves immediately
   const crypto = require("crypto");
-  const EventBus = require("../bus");
+  const EventBus = require("../../coordination/bus");
   const existing = listSubscribers(projectRoot, agentType);
   let subscriberId = "";
   let preRegistrationError = null;
@@ -584,15 +587,11 @@ async function spawnManagedHostAgent(
   const argText = args.length > 0 ? ` ${args.map(shellEscape).join(" ")}` : "";
 
   const titleCmd = buildTitleCmd(nickname);
-  const hasPreRegisteredSubscriber = !!subscriberId;
 
   // Pass env vars to Horizon via the env parameter (Horizon will set them for the child process)
   const env = {
     UFOO_LAUNCH_MODE: "host",
   };
-  if (requireActivityMonitor) {
-    env.UFOO_FORCE_PTY = "1";
-  }
   if (subscriberId) {
     env.UFOO_SUBSCRIBER_ID = subscriberId;
   }
@@ -608,32 +607,18 @@ async function spawnManagedHostAgent(
     }
   }
 
-  let runCmd;
-  if (hasPreRegisteredSubscriber) {
-    // Group mode: use ufoo launcher for activity_state monitoring
-    // This enables ReadyDetector and bootstrap to work correctly
-    const ufooRunner = resolveUfooRunnerPath();
-    const launchCmd = `${shellEscape(process.execPath)} ${shellEscape(ufooRunner)} agent-pty-runner ${shellEscape(normalizedAgent)}${argText}`.trim();
-    runCmd = titleCmd
-      ? `cd ${shellEscape(projectRoot)} && ${titleCmd} && ${launchCmd}`
-      : `cd ${shellEscape(projectRoot)} && ${launchCmd}`;
-    // Force PTY wrapper so ReadyDetector + ActivityDetector work for activity_state monitoring.
-    // Horizon sets UFOO_DISABLE_PTY=1 unconditionally; UFOO_FORCE_PTY=1 takes priority over it.
-    env.UFOO_FORCE_PTY = "1";
-  } else {
-    if (preRegistrationError) {
-      console.error(
-        `[host-launch] pre-registration failed for ${nickname || agentType}: ${preRegistrationError.message || String(preRegistrationError)}`
-      );
-    }
-    // Fallback launch still goes through the regular agent launcher binary.
-    // For group/bootstrap-monitored flows we also force the PTY wrapper so
-    // activity_state can progress out of "starting" after self-registration.
-    const directCmd = `${binary}${argText}`;
-    runCmd = titleCmd
-      ? `cd ${shellEscape(projectRoot)} && ${titleCmd} && ${directCmd}`
-      : `cd ${shellEscape(projectRoot)} && ${directCmd}`;
+  // Launch agent binary directly; launcher.js creates inject.sock and
+  // handles activity_state monitoring internally via its own PTY wrapper.
+  if (preRegistrationError) {
+    console.error(
+      `[host-launch] pre-registration failed for ${nickname || agentType}: ${preRegistrationError.message || String(preRegistrationError)}`
+    );
   }
+  env.UFOO_FORCE_PTY = "1";
+  const directCmd = `${binary}${argText}`;
+  const runCmd = titleCmd
+    ? `cd ${shellEscape(projectRoot)} && ${titleCmd} && ${directCmd}`
+    : `cd ${shellEscape(projectRoot)} && ${directCmd}`;
   createOptions.command = runCmd;
   createOptions.env = env;
 
@@ -671,7 +656,7 @@ async function spawnInternalAgent(
   fs.mkdirSync(logDir, { recursive: true });
 
   const crypto = require("crypto");
-  const EventBus = require("../bus");
+  const EventBus = require("../../coordination/bus");
   const children = [];
   const subscriberIds = [];
 
@@ -707,10 +692,7 @@ async function spawnInternalAgent(
       ? (count > 1 ? `${nickname}-${i + 1}` : nickname)
       : "";
     const providerSessionId = typeof options.providerSessionId === "string" ? options.providerSessionId.trim() : "";
-    const usePty = typeof options.usePty === "boolean"
-      ? options.usePty
-      : process.env.UFOO_INTERNAL_PTY !== "0";
-    const launchMode = usePty ? "internal-pty" : "internal";
+    const launchMode = "internal";
 
     // 传递 launch_mode 和 parent PID 到 join
     const joinResult = await bus.subscriberManager.join(sessionId, agentType, requestedNickname, {
@@ -722,10 +704,9 @@ async function spawnInternalAgent(
     bus.saveBusData();
 
     const managedBootstrap = applyDefaultManagedBootstrap(projectRoot, normalizedAgent, extraArgs, extraEnv);
-    const runnerCmd = usePty ? "agent-pty-runner" : "agent-runner";
+    const runnerCmd = "agent-runner";
     const args = managedBootstrap.args;
     const child = spawn(process.execPath, [runner, runnerCmd, agent, ...args], {
-      // 关键改动：不使用 detached，daemon 作为父进程
       detached: false,
       stdio: ["ignore", errLog, errLog],
       cwd: projectRoot,
@@ -733,17 +714,16 @@ async function spawnInternalAgent(
         ...process.env,
         ...(managedBootstrap.extraEnv && typeof managedBootstrap.extraEnv === "object" ? managedBootstrap.extraEnv : {}),
         UFOO_INTERNAL_AGENT: "1",
-        UFOO_INTERNAL_PTY: usePty ? "1" : "0",
-        UFOO_SUBSCRIBER_ID: subscriberId,  // 直接传递 subscriber ID
+        UFOO_SUBSCRIBER_ID: subscriberId,
         UFOO_NICKNAME: finalNickname,
-        UFOO_LAUNCH_MODE: usePty ? "internal-pty" : "internal",
+        UFOO_LAUNCH_MODE: "internal",
         UFOO_PARENT_PID: String(originalPid),
         ...(providerSessionId ? { UFOO_PROVIDER_SESSION_ID: providerSessionId } : {}),
       },
     });
 
     // Update bus data with the actual child PID so isMetaActive
-    // can detect when the ptyRunner process dies.
+    // can detect when the runner process dies.
     try {
       bus.loadBusData();
       if (bus.busData.agents && bus.busData.agents[subscriberId]) {
@@ -953,8 +933,7 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
     throw new Error(`unsupported agent type: ${agent}`);
   }
 
-  if (mode === "internal" || mode === "internal-pty") {
-    const usePty = mode === "internal-pty";
+  if (mode === "internal") {
     const result = await spawnInternalAgent(
       projectRoot,
       normalizedAgent,
@@ -963,7 +942,7 @@ async function launchAgent(projectRoot, agent, count = 1, nickname = "", process
       processManager,
       launchEnvObject,
       extraArgs,
-      { usePty }
+      {}
     );
     return { mode, launchScope, subscriberIds: result.subscriberIds };
   }
@@ -1100,6 +1079,9 @@ function buildResumeArgs(agent, sessionId) {
   if (!sessionId) return [];
   if (agent === "codex") return ["resume", sessionId];
   if (agent === "claude") return ["--session-id", sessionId];
+  // Agy resumes by conversation UUID; bin/uagy.js de-duplicates if the same
+  // flag is already injected via provider_session_id readback.
+  if (agent === "agy") return [`--conversation=${sessionId}`];
   return [];
 }
 
@@ -1152,7 +1134,7 @@ function collectRecoverableAgents(projectRoot, target = "") {
       continue;
     }
     const agent = normalizeAgentType(meta.agent_type);
-    if (agent !== "codex" && agent !== "claude") {
+    if (agent !== "codex" && agent !== "claude" && agent !== "agy") {
       skipped.push({ id, reason: "unsupported agent type" });
       continue;
     }
@@ -1196,7 +1178,7 @@ async function resumeAgents(projectRoot, target = "", processManager = null) {
     const args = buildResumeArgs(item.agent, sessionId);
     let reused = false;
     let resumedId = item.id;
-    if (mode === "internal" || mode === "internal-pty") {
+    if (mode === "internal") {
       // Internal agents have no terminal/pane to reattach. Start a fresh
       // daemon-managed runner and replace the old recoverable registration.
       // The provider session is still reused via the normal provider args.
@@ -1207,9 +1189,9 @@ async function resumeAgents(projectRoot, target = "", processManager = null) {
         1,
         nickname,
         processManager,
-        { UFOO_SKIP_SESSION_PROBE: "1" },
+        { UFOO_SKIP_SESSION_RESOLVE: "1" },
         args,
-        { replaceAgentId: item.id, providerSessionId: sessionId, usePty: mode === "internal-pty" }
+        { replaceAgentId: item.id, providerSessionId: sessionId }
       );
       resumedId = launchResult.subscriberIds && launchResult.subscriberIds[0]
         ? launchResult.subscriberIds[0]
@@ -1217,7 +1199,7 @@ async function resumeAgents(projectRoot, target = "", processManager = null) {
     } else {
       reused = await tryReuseTerminal(projectRoot, item.id, item.meta, item.agent, sessionId);
       if (!reused) {
-        const envPrefix = "UFOO_SKIP_SESSION_PROBE=1";
+        const envPrefix = "UFOO_SKIP_SESSION_RESOLVE=1";
         if (mode === "tmux") {
           // eslint-disable-next-line no-await-in-loop
           await spawnTmuxWindow(projectRoot, item.agent, nickname, args, envPrefix);
@@ -1334,5 +1316,10 @@ module.exports = {
     resolveConfiguredLaunchMode,
     resolveHostLaunchContext,
     resolveNativeTerminalApp,
+    normalizeLaunchAgent,
+    toBusAgentType,
+    toTerminalBinary,
+    toTmuxBinary,
+    buildResumeArgs,
   },
 };

package/src/{daemon → runtime/daemon}/promptLoop.js

@@ -1,4 +1,4 @@
-const { finalizeRouterPayload } = require("../controller/routerFinalize");
+const { finalizeRouterPayload } = require("../../orchestration/controller/routerFinalize");
 
 function normalizePayload(payload) {
   if (!payload || typeof payload !== "object") {

package/src/{daemon → runtime/daemon}/promptRequest.js

@@ -1,34 +1,34 @@
 "use strict";
 
-const { IPC_RESPONSE_TYPES } = require("../shared/eventContract");
+const { IPC_RESPONSE_TYPES } = require("../contracts/eventContract");
 const {
   listControllerInboxEntries,
   consumeControllerInboxEntries,
-} = require("../report/store");
+} = require("../../coordination/report/store");
 const { isGlobalControllerProjectRoot } = require("../projects");
 const {
   resolveGateRouterConfig,
   shouldUseGateRouter,
-} = require("../controller/gateRouter");
+} = require("../../orchestration/controller/gateRouter");
 const {
   CONTROLLER_MODES,
   applyControllerModeForMessage,
   resolveControllerMode,
-} = require("../controller/flags");
+} = require("../../orchestration/controller/flags");
 const {
   resolveLoopRuntimeOptions,
   runPromptWithControllerLoop,
-} = require("../agent/loopRuntime");
+} = require("../../agents/controller/loopRuntime");
 const {
   appendShadowDiff,
   createLoopObserver,
-} = require("../agent/loopObservability");
+} = require("../../agents/controller/loopObservability");
 const {
   DEFAULT_SHADOW_SAMPLING_RATE,
   createShadowBudgetBreaker,
   createShadowGuard,
   shouldSampleShadow,
-} = require("../controller/shadowGuard");
+} = require("../../orchestration/controller/shadowGuard");
 
 function normalizeProjectRoute(route) {
   if (!route || typeof route !== "object") return null;

package/src/runtime/daemon/providerSessions.js

@@ -0,0 +1,230 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { loadAgentsData, saveAgentsData } = require("../../coordination/state/agentsStore");
+const { getUfooPaths } = require("../../coordination/state/paths");
+
+function persistProviderSession(projectRoot, subscriberId, payload) {
+  const filePath = getUfooPaths(projectRoot).agentsFile;
+  const data = loadAgentsData(filePath);
+  const meta = data.agents[subscriberId] || {};
+  data.agents[subscriberId] = {
+    ...meta,
+    provider_session_id: payload.sessionId || "",
+    provider_session_source: payload.source || "",
+    provider_session_updated_at: new Date().toISOString(),
+  };
+  saveAgentsData(filePath, data);
+}
+
+function loadProviderSessionCache(projectRoot) {
+  const filePath = getUfooPaths(projectRoot).agentsFile;
+  const data = loadAgentsData(filePath);
+  const cache = new Map();
+  for (const [id, meta] of Object.entries(data.agents || {})) {
+    if (meta && meta.provider_session_id) {
+      cache.set(id, {
+        sessionId: meta.provider_session_id,
+        source: meta.provider_session_source || "",
+        updated_at: meta.provider_session_updated_at || "",
+      });
+    }
+  }
+  return cache;
+}
+
+/**
+ * Resolve Claude Code session ID directly from session file.
+ * Claude writes ~/.claude/sessions/<pid>.json with { sessionId, pid, cwd, ... }
+ */
+function resolveClaudeSessionFromFile(pid) {
+  if (!pid) return null;
+  const filePath = path.join(os.homedir(), ".claude", "sessions", `${pid}.json`);
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const data = JSON.parse(fs.readFileSync(filePath, "utf8"));
+    const sessionId = data.sessionId || data.session_id || "";
+    if (!sessionId) return null;
+    return { sessionId, source: filePath };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve Codex session ID from session rollout files.
+ * Codex writes ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<id>.jsonl
+ * First line contains { type: "session_meta", payload: { id, cwd, ... } }
+ */
+function resolveCodexSessionFromFile(cwd) {
+  if (!cwd) return null;
+  try {
+    const now = new Date();
+    // Check today and yesterday (session may have started before midnight)
+    const dates = [now];
+    const yesterday = new Date(now);
+    yesterday.setDate(yesterday.getDate() - 1);
+    dates.push(yesterday);
+
+    let bestMatch = null;
+    let bestMtime = 0;
+
+    for (const d of dates) {
+      const yyyy = String(d.getFullYear());
+      const mm = String(d.getMonth() + 1).padStart(2, "0");
+      const dd = String(d.getDate()).padStart(2, "0");
+      const dir = path.join(os.homedir(), ".codex", "sessions", yyyy, mm, dd);
+      if (!fs.existsSync(dir)) continue;
+
+      const files = fs.readdirSync(dir)
+        .filter((f) => f.startsWith("rollout-") && f.endsWith(".jsonl"));
+
+      for (const file of files) {
+        const filePath = path.join(dir, file);
+        try {
+          const stat = fs.statSync(filePath);
+          if (stat.mtimeMs <= bestMtime) continue;
+
+          // Read first line for session_meta
+          const fd = fs.openSync(filePath, "r");
+          const buf = Buffer.alloc(4096);
+          const bytesRead = fs.readSync(fd, buf, 0, 4096, 0);
+          fs.closeSync(fd);
+          const firstLine = buf.toString("utf8", 0, bytesRead).split("\n")[0];
+          if (!firstLine) continue;
+
+          const record = JSON.parse(firstLine);
+          const payload = record.payload || record;
+          const sessionCwd = payload.cwd || "";
+          const sessionId = payload.id || "";
+
+          if (sessionId && sessionCwd === cwd && stat.mtimeMs > bestMtime) {
+            bestMatch = { sessionId, source: filePath };
+            bestMtime = stat.mtimeMs;
+          }
+        } catch {
+          continue;
+        }
+      }
+    }
+    return bestMatch;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Resolve provider session ID directly from session files.
+ * @param {string} agentType - "claude-code" or "codex"
+ * @param {object} opts - { pid, cwd }
+ */
+function resolveSessionFromFile(agentType, opts = {}) {
+  if (agentType === "claude-code") {
+    return resolveClaudeSessionFromFile(opts.pid);
+  }
+  if (agentType === "codex") {
+    return resolveCodexSessionFromFile(opts.cwd);
+  }
+  return null;
+}
+
+/**
+ * Retry reading session file (agent may not have written it yet)
+ */
+async function resolveSessionFromFileWithRetries(agentType, opts = {}, attempts = 10, intervalMs = 1000) {
+  for (let i = 0; i < attempts; i += 1) {
+    const resolved = resolveSessionFromFile(agentType, opts);
+    if (resolved && resolved.sessionId) return resolved;
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return null;
+}
+
+/**
+ * Schedule provider session resolution.
+ * Uses provider session files only. This intentionally avoids injecting
+ * `/ufoo <nickname>` / `$ufoo <nickname>` into agent terminals.
+ *
+ * @param {Object} options
+ * @param {string} options.projectRoot - Project root directory
+ * @param {string} options.subscriberId - Subscriber ID (e.g., "claude-code:abc123")
+ * @param {string} options.agentType - Agent type ("claude-code" or "codex")
+ * @param {number} options.agentPid - Agent child process PID (for claude-code)
+ * @param {string} options.agentCwd - Agent working directory (for codex)
+ * @param {number} options.delayMs - Delay before starting resolution
+ * @param {number} options.fileAttempts - File read retry attempts
+ * @param {number} options.fileIntervalMs - File read retry interval
+ * @param {Function} options.onResolved - Callback when session ID is found
+ */
+function scheduleProviderSessionResolve({
+  projectRoot,
+  subscriberId,
+  agentType,
+  agentPid = 0,
+  agentCwd = "",
+  delayMs = 3000,
+  fileAttempts = 10,
+  fileIntervalMs = 1000,
+  onResolved = null,
+}) {
+  if (!subscriberId || !agentType) return null;
+  if (agentType !== "codex" && agentType !== "claude-code") return null;
+
+  let executed = false;
+  let cancelled = false;
+  let timer = null;
+
+  const execute = async () => {
+    if (executed || cancelled) return;
+    executed = true;
+    if (timer) {
+      clearTimeout(timer);
+      timer = null;
+    }
+
+    // 1. Try direct file read (fast, non-invasive)
+    const fileOpts = { pid: agentPid, cwd: agentCwd || projectRoot };
+    const fileResolved = await resolveSessionFromFileWithRetries(
+      agentType, fileOpts, fileAttempts, fileIntervalMs,
+    );
+    if (cancelled) return;
+    if (fileResolved && fileResolved.sessionId) {
+      persistProviderSession(projectRoot, subscriberId, fileResolved);
+      if (typeof onResolved === "function") {
+        onResolved(subscriberId, fileResolved);
+      }
+      return;
+    }
+
+    // No terminal injection fallback. Session IDs are resolved from provider files only.
+  };
+
+  // Schedule delayed execution
+  timer = setTimeout(execute, delayMs);
+
+  // Return handle for early trigger or cancellation
+  return {
+    subscriberId,
+    triggerNow: execute,
+    cancel: () => {
+      cancelled = true;
+      executed = true;
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+    },
+  };
+}
+
+module.exports = {
+  scheduleProviderSessionResolve,
+  resolveSessionFromFile,
+  persistProviderSession,
+  loadProviderSessionCache,
+  __private: {
+    resolveClaudeSessionFromFile,
+    resolveCodexSessionFromFile,
+  },
+};

package/src/{daemon → runtime/daemon}/reporting.js

@@ -1,14 +1,14 @@
 const fs = require("fs");
-const EventBus = require("../bus");
-const { BUS_STATUS_PHASES } = require("../shared/eventContract");
+const EventBus = require("../../coordination/bus");
+const { BUS_STATUS_PHASES } = require("../contracts/eventContract");
 const {
   REPORT_PHASES,
   normalizeReportInput,
   appendReport,
   updateReportState,
   appendControllerInboxEntry,
-} = require("../report/store");
-const { getUfooPaths } = require("../ufoo/paths");
+} = require("../../coordination/report/store");
+const { getUfooPaths } = require("../../coordination/state/paths");
 const { resolveDisplayNickname } = require("./nicknameScope");
 
 function resolveAgentDisplayName(projectRoot, agentId) {

package/src/{daemon → runtime/daemon}/run.js

@@ -1,7 +1,7 @@
 const path = require("path");
 const { startDaemon, stopDaemon, isRunning } = require("./index");
-const { loadConfig, defaultAgentModelForProvider } = require("../config");
-const { resolveNodeExecutable } = require("../utils/nodeExecutable");
+const { loadConfig, defaultAgentModelForProvider } = require("../../config");
+const { resolveNodeExecutable } = require("../process/nodeExecutable");
 
 function runDaemonCli(argv) {
   const cmd = argv[1] || "start";
@@ -20,7 +20,7 @@ function runDaemonCli(argv) {
     if (isRunning(projectRoot)) return;
     if (!process.env.UFOO_DAEMON_CHILD) {
       const { spawn } = require("child_process");
-      const child = spawn(resolveNodeExecutable(), [path.join(__dirname, "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
+      const child = spawn(resolveNodeExecutable(), [path.join(__dirname, "..", "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
         detached: true,
         stdio: "ignore",
         env: { ...process.env, UFOO_DAEMON_CHILD: "1" },
@@ -57,7 +57,7 @@ function runDaemonCli(argv) {
     if (!process.env.UFOO_DAEMON_CHILD) {
       const { spawn } = require("child_process");
       const childEnv = { ...process.env, UFOO_DAEMON_CHILD: "1" };
-      const child = spawn(resolveNodeExecutable(), [path.join(__dirname, "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
+      const child = spawn(resolveNodeExecutable(), [path.join(__dirname, "..", "..", "..", "bin", "ufoo.js"), "daemon", "start"], {
         detached: true,
         stdio: "ignore",
         env: childEnv,

package/src/{daemon → runtime/daemon}/soloBootstrap.js

@@ -1,24 +1,24 @@
 "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 EventBus = require("../../coordination/bus");
+const { prepareUcodeBootstrap } = require("../../code/launcher/ucodeBootstrap");
+const { isMetaActive } = require("../../coordination/bus/utils");
+const { getUfooPaths } = require("../../coordination/state/paths");
 const {
   applyProjectNicknamePrefix,
   resolveDisplayNickname,
   resolveScopedNickname,
 } = require("./nicknameScope");
-const { loadAgentsData, saveAgentsData } = require("../ufoo/agentsStore");
+const { loadAgentsData, saveAgentsData } = require("../../coordination/state/agentsStore");
 const {
   loadPromptProfileRegistry,
   resolvePromptProfileReference,
-} = require("../group/promptProfiles");
+} = require("../../orchestration/groups/promptProfiles");
 const {
   buildSoloPromptMetadata,
   composeSoloBootstrapPrompt,
-} = require("../group/bootstrap");
+} = require("../../orchestration/groups/bootstrap");
 
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));