u-foo 3.0.10 → 3.0.11

package/src/app/chat/ChatController.js

@@ -0,0 +1,433 @@
+"use strict";
+
+/**
+ * Headless ChatController — composition root for Ink + Rust chat adapters.
+ *
+ * Owns stream state, STATUS→agents snapshot, slash/submit wiring ports.
+ * View adapters attach via `ports` (dispatch / publish / log / setStatus).
+ */
+
+const { createThrottledSender, createChatStreamState } = require("./streamState");
+const {
+  loadChatHistory,
+  loadInputHistory,
+  appendChatHistory,
+  appendInputHistory,
+  chatHistoryOptionsForScope,
+  chatHistoryFilePath,
+} = require("./historyStore");
+const { bootstrapEnvironment, ensureSubscriberId } = require("./bootstrap");
+const {
+  buildAgentMaps,
+  resolveAgentId,
+  normalizeStatusToAgentsSnapshot,
+  toInkAgentsDispatchList,
+} = require("./agentDirectory");
+const { buildPromptIpcRequest, buildDirectBusSendRequest } = require("./ipcBuilders");
+const { IPC_REQUEST_TYPES } = require("../../runtime/contracts/eventContract");
+
+function createChatController({
+  projectRoot = process.cwd(),
+  globalMode = false,
+  ports = {},
+} = {}) {
+  const view = {
+    dispatch: typeof ports.dispatch === "function" ? ports.dispatch : () => {},
+    logMessage: typeof ports.logMessage === "function" ? ports.logMessage : () => {},
+    setStatus: typeof ports.setStatus === "function" ? ports.setStatus : () => {},
+    publish: typeof ports.publish === "function" ? ports.publish : () => {},
+    getState: typeof ports.getState === "function" ? ports.getState : () => ({}),
+    mapAgentsForDispatch: typeof ports.mapAgentsForDispatch === "function"
+      ? ports.mapAgentsForDispatch
+      : (snapshot) => snapshot.agents,
+    appendHistory: typeof ports.appendHistory === "function"
+      ? ports.appendHistory
+      : (type, text, meta) => appendChatHistory(projectRoot, type, text, meta, { globalMode }),
+    displayNameForPublisher: typeof ports.displayNameForPublisher === "function"
+      ? ports.displayNameForPublisher
+      : (value) => value,
+    send: typeof ports.send === "function" ? ports.send : null,
+  };
+
+  let started = false;
+  let statusTimer = null;
+  let streamState = null;
+  let requestDaemonStatus = null;
+  let commandExecutor = null;
+  let submitHandler = null;
+  let daemonSend = typeof view.send === "function" ? view.send : () => {};
+
+  const session = {
+    agents: [],
+    metaMap: new Map(),
+    labelMap: new Map(),
+    footer: "",
+    cron: null,
+    loop: null,
+    targetAgent: null,
+    pending: null,
+  };
+
+  function setSend(fn) {
+    daemonSend = typeof fn === "function" ? fn : () => {};
+  }
+
+  function applyStatus(data = {}) {
+    const snapshot = normalizeStatusToAgentsSnapshot(data);
+    session.agents = snapshot.agents.map((row) => row.id || row.fullId);
+    session.metaMap = snapshot.metaMap;
+    session.labelMap = snapshot.labelMap;
+    session.footer = snapshot.footer;
+    session.cron = snapshot.cron;
+    session.loop = snapshot.loop;
+    view.publish("agents.snapshot", {
+      agents: snapshot.agents.map((row) => ({
+        id: row.id,
+        label: row.label,
+        activity_state: row.activity_state || "",
+        activity_detail: row.activity_detail || "",
+      })),
+      footer: snapshot.footer,
+      cron: snapshot.cron,
+      loop: snapshot.loop,
+    });
+    view.dispatch({ type: "agents/set", list: view.mapAgentsForDispatch(snapshot) });
+    return snapshot;
+  }
+
+  function patchAgentActivity(agentId, patch = {}) {
+    if (!agentId) return;
+    const existing = session.metaMap.get(agentId) || { id: agentId };
+    const next = { ...existing, ...patch };
+    session.metaMap.set(agentId, next);
+    const rebuilt = normalizeStatusToAgentsSnapshot({
+      active: session.agents,
+      active_meta: session.agents.map((id) => session.metaMap.get(id) || { id }),
+    });
+    session.footer = rebuilt.footer;
+    view.publish("agents.patch", {
+      agents: rebuilt.agents.map((row) => ({
+        id: row.id,
+        label: row.label,
+        activity_state: row.activity_state || "",
+        activity_detail: row.activity_detail || "",
+      })),
+      footer: rebuilt.footer,
+    });
+  }
+
+  function getAgentLabel(id) {
+    return session.labelMap.get(id) || (session.metaMap.get(id) || {}).nickname || id;
+  }
+
+  function ensureCommandExecutor() {
+    if (commandExecutor) return commandExecutor;
+    const { createCommandExecutor } = require("./commandExecutor");
+    const { parseCommand } = require("./commands");
+    const { startDaemon, stopDaemon } = require("./transport");
+    const AgentActivator = require("../../coordination/bus/activate");
+    const fs = require("fs");
+
+    commandExecutor = createCommandExecutor({
+      projectRoot,
+      getActiveProjectRoot: typeof ports.getActiveProjectRoot === "function"
+        ? ports.getActiveProjectRoot
+        : () => projectRoot,
+      parseCommand,
+      escapeBlessed: (value) => String(value == null ? "" : value),
+      logMessage: view.logMessage,
+      resolveStatusLine: (text) => view.setStatus(text),
+      renderScreen: () => {},
+      clearLog: typeof ports.clearLog === "function"
+        ? ports.clearLog
+        : () => {
+          try {
+            const root = typeof ports.getActiveProjectRoot === "function"
+              ? ports.getActiveProjectRoot()
+              : projectRoot;
+            const opts = typeof ports.getHistoryOptions === "function"
+              ? ports.getHistoryOptions()
+              : { globalMode };
+            const file = chatHistoryFilePath(root, opts);
+            if (file && fs.existsSync(file)) fs.writeFileSync(file, "");
+          } catch {
+            // ignore
+          }
+          view.publish("transcript.reset", {});
+          view.dispatch({ type: "log/clear" });
+        },
+      getActiveAgents: () => session.agents.slice(),
+      getActiveAgentMetaMap: () => session.metaMap,
+      getAgentLabel,
+      isDaemonRunning: typeof ports.isDaemonRunning === "function"
+        ? ports.isDaemonRunning
+        : () => true,
+      startDaemon: (root, options = {}) => startDaemon(root || projectRoot, options),
+      stopDaemon: (root, options = {}) => stopDaemon(root || projectRoot, options),
+      restartDaemon: typeof ports.restartDaemon === "function"
+        ? ports.restartDaemon
+        : async () => {},
+      send: (req) => daemonSend(req),
+      requestStatus: () => {
+        if (typeof requestDaemonStatus === "function") requestDaemonStatus();
+        else daemonSend({ type: IPC_REQUEST_TYPES.STATUS });
+      },
+      requestCron: (payload = {}) => daemonSend({ type: IPC_REQUEST_TYPES.CRON, ...payload }),
+      activateAgent: async (target) => {
+        const activator = new AgentActivator(projectRoot);
+        await activator.activate(target);
+      },
+      globalMode: Boolean(globalMode),
+      listProjects: typeof ports.listProjects === "function"
+        ? ports.listProjects
+        : () => [],
+      getCurrentProject: typeof ports.getCurrentProject === "function"
+        ? ports.getCurrentProject
+        : () => ({ project_root: projectRoot }),
+      switchProject: typeof ports.switchProject === "function"
+        ? ports.switchProject
+        : async () => ({ ok: false, error: "project switching unavailable" }),
+      toggleMultiWindow: typeof ports.toggleMultiWindow === "function"
+        ? ports.toggleMultiWindow
+        : () => {
+          view.logMessage("system", "Multi-window unavailable in this host.");
+        },
+      applyChatSettings: typeof ports.applyChatSettings === "function"
+        ? ports.applyChatSettings
+        : null,
+    });
+    return commandExecutor;
+  }
+
+  function ensureSubmitHandler() {
+    if (submitHandler) return submitHandler;
+    const { createInputSubmitHandler } = require("./inputSubmitHandler");
+    const { parseAtTarget } = require("./commands");
+    const submitState = {};
+    Object.defineProperties(submitState, {
+      targetAgent: {
+        get: () => session.targetAgent,
+        set: (next) => {
+          session.targetAgent = next || null;
+        },
+      },
+      pending: {
+        get: () => session.pending,
+        set: (next) => {
+          session.pending = next || null;
+        },
+      },
+      activeAgentMetaMap: {
+        get: () => session.metaMap,
+      },
+    });
+    submitHandler = createInputSubmitHandler({
+      state: submitState,
+      parseAtTarget,
+      resolveAgentId: (label) => resolveAgentId({
+        label,
+        activeAgents: session.agents,
+        labelMap: session.labelMap,
+        lookupNickname: (nickname) => {
+          for (const [id, meta] of session.metaMap.entries()) {
+            if (!meta) continue;
+            if (
+              meta.nickname === nickname
+              || meta.scoped_nickname === nickname
+              || meta.display_nickname === nickname
+            ) {
+              return id;
+            }
+          }
+          return null;
+        },
+      }),
+      executeCommand: async (text) => ensureCommandExecutor().executeCommand(text),
+      queueStatusLine: (text) => view.setStatus(text),
+      send: (req) => daemonSend(req),
+      logMessage: view.logMessage,
+      getAgentLabel,
+      escapeBlessed: (value) => String(value == null ? "" : value),
+      markPendingDelivery: (agentId) => {
+        if (streamState) streamState.markPendingDelivery(agentId, getAgentLabel(agentId));
+      },
+      clearTargetAgent: () => {
+        session.targetAgent = null;
+        view.publish("prompt.set_prefix", { prefix: "› " });
+      },
+      setTargetAgent: (agentId) => {
+        session.targetAgent = agentId || null;
+        if (!agentId) {
+          view.publish("prompt.set_prefix", { prefix: "› " });
+          return;
+        }
+        const label = getAgentLabel(agentId);
+        view.publish("prompt.set_prefix", { prefix: `›@${label} ` });
+      },
+      enterAgentView: (agentId, options = {}) => {
+        if (typeof ports.enterAgentView === "function") {
+          return ports.enterAgentView(agentId, options);
+        }
+        view.logMessage("system", "Agent enter unavailable in this host.");
+      },
+      getAgentAdapter: (agentId) => {
+        if (typeof ports.getAgentAdapter === "function") {
+          return ports.getAgentAdapter(agentId);
+        }
+        try {
+          const { createTerminalAdapterRouter } = require("../../runtime/terminal/adapterRouter");
+          const meta = session.metaMap.get(agentId) || {};
+          const launchMode = String(meta.launch_mode || meta.launchMode || "").trim();
+          return createTerminalAdapterRouter().getAdapter({ launchMode, agentId, meta });
+        } catch {
+          return null;
+        }
+      },
+      activateAgent: async (agentId) => {
+        if (typeof ports.activateAgent === "function") {
+          return ports.activateAgent(agentId);
+        }
+        const AgentActivator = require("../../coordination/bus/activate");
+        const root = typeof ports.getActiveProjectRoot === "function"
+          ? ports.getActiveProjectRoot()
+          : projectRoot;
+        const activator = new AgentActivator(root || projectRoot);
+        await activator.activate(agentId);
+      },
+      focusMultiPane: typeof ports.focusMultiPane === "function"
+        ? ports.focusMultiPane
+        : null,
+      commitInputHistory: (value) => {
+        const root = typeof ports.getActiveProjectRoot === "function"
+          ? ports.getActiveProjectRoot()
+          : projectRoot;
+        const opts = typeof ports.getHistoryOptions === "function"
+          ? ports.getHistoryOptions()
+          : { globalMode };
+        appendInputHistory(root || projectRoot, value, opts);
+      },
+      focusInput: () => {},
+      renderScreen: () => {},
+      getShellCwd: () => {
+        if (typeof ports.getActiveProjectRoot === "function") {
+          return ports.getActiveProjectRoot() || projectRoot;
+        }
+        return projectRoot;
+      },
+    });
+    return submitHandler;
+  }
+
+  async function submitInput(text) {
+    const handler = ensureSubmitHandler();
+    await handler.handleSubmit(text);
+  }
+
+  function start(options = {}) {
+    if (started) return;
+    started = true;
+    if (typeof options.send === "function") setSend(options.send);
+    streamState = createChatStreamState({
+      dispatch: view.dispatch,
+      appendHistory: view.appendHistory,
+      displayNameForPublisher: (publisher) => {
+        if (session.labelMap.has(publisher)) return session.labelMap.get(publisher);
+        return view.displayNameForPublisher(publisher);
+      },
+    });
+    const sendStatus = typeof options.sendStatus === "function"
+      ? options.sendStatus
+      : () => daemonSend({ type: IPC_REQUEST_TYPES.STATUS });
+    requestDaemonStatus = createThrottledSender(sendStatus, 500);
+    const intervalMs = Number(options.statusIntervalMs) > 0 ? Number(options.statusIntervalMs) : 3000;
+    statusTimer = setInterval(() => {
+      try {
+        requestDaemonStatus();
+      } catch {
+        // ignore poll errors
+      }
+    }, intervalMs);
+    if (typeof statusTimer.unref === "function") statusTimer.unref();
+    try {
+      requestDaemonStatus();
+    } catch {
+      // ignore
+    }
+  }
+
+  function stop() {
+    if (statusTimer) {
+      clearInterval(statusTimer);
+      statusTimer = null;
+    }
+    if (streamState && typeof streamState.flushDeltas === "function") {
+      streamState.flushDeltas();
+    }
+    started = false;
+  }
+
+  return {
+    projectRoot,
+    globalMode,
+    session,
+    bootstrapEnvironment: (root = projectRoot, options = {}) => bootstrapEnvironment(root, {
+      globalMode,
+      ...options,
+    }),
+    ensureSubscriberId: (root = projectRoot) => ensureSubscriberId(root),
+    loadChatHistory: (cap = 200, options = {}) => loadChatHistory(projectRoot, cap, {
+      globalMode,
+      ...options,
+    }),
+    loadInputHistory: (cap = 200, options = {}) => loadInputHistory(projectRoot, cap, {
+      globalMode,
+      ...options,
+    }),
+    appendChatHistory: (type, text, meta = {}, options = {}) => appendChatHistory(
+      projectRoot,
+      type,
+      text,
+      meta,
+      { globalMode, ...options },
+    ),
+    appendInputHistory: (value, options = {}) => appendInputHistory(projectRoot, value, {
+      globalMode,
+      ...options,
+    }),
+    chatHistoryOptionsForScope,
+    getStreamState: () => streamState,
+    getAgentsFooter: () => session.footer,
+    getAgentsSnapshot: () => ({
+      agents: session.agents.map((id) => {
+        const meta = session.metaMap.get(id) || {};
+        return {
+          id,
+          label: getAgentLabel(id),
+          activity_state: meta.activity_state || "",
+          activity_detail: meta.activity_detail || "",
+        };
+      }),
+      footer: session.footer,
+      cron: session.cron,
+      loop: session.loop,
+    }),
+    applyStatus,
+    patchAgentActivity,
+    setSend,
+    submitInput,
+    ensureCommandExecutor,
+    buildPromptIpcRequest,
+    buildDirectBusSendRequest,
+    buildAgentMaps,
+    requestDaemonStatus: () => {
+      if (typeof requestDaemonStatus === "function") requestDaemonStatus();
+    },
+    start,
+    stop,
+  };
+}
+
+module.exports = {
+  createChatController,
+  toInkAgentsDispatchList,
+};

package/src/app/chat/agentDirectory.js

@@ -79,10 +79,73 @@ function clampAgentWindowWithSelection({
   return nextStart;
 }
 
+/**
+ * Normalize daemon STATUS payload into agents list + footer string.
+ * Shared by Ink dashboard and Rust `agents.snapshot`.
+ */
+function normalizeStatusToAgentsSnapshot(data = {}) {
+  const activeIds = Array.isArray(data.active) ? data.active : [];
+  const metaList = Array.isArray(data.active_meta) ? data.active_meta : [];
+  const { labelMap, metaMap } = buildAgentMaps(activeIds, metaList);
+  const agents = activeIds.map((id) => {
+    const meta = metaMap.get(id) || {};
+    const colon = String(id).indexOf(":");
+    const fallbackType = colon > 0 ? String(id).slice(0, colon) : String(id);
+    const fallbackId = colon > 0 ? String(id).slice(colon + 1) : "";
+    const label = labelMap.get(id) || id;
+    const activity = String(meta.activity_state || "").trim();
+    return {
+      ...meta,
+      id,
+      fullId: id,
+      label,
+      type: meta.type || fallbackType,
+      agentId: meta.id || fallbackId,
+      nickname: label,
+      activity_state: activity,
+      activity_detail: String(meta.activity_detail || ""),
+      launch_mode: meta.launch_mode || meta.launchMode || "",
+    };
+  });
+  const footer = agents.length === 0
+    ? "no agents"
+    : agents.map((agent) => {
+      const mark = agent.activity_state === "working" ? "*"
+        : agent.activity_state === "waiting_input" ? "?"
+          : agent.activity_state === "blocked" ? "!"
+            : "";
+      return mark ? `${mark}${agent.label}` : agent.label;
+    }).join(" · ");
+  return {
+    agents,
+    footer,
+    labelMap,
+    metaMap,
+    cron: data.cron || null,
+    loop: data.loop || null,
+  };
+}
+
+/**
+ * Ink chatReducer expects `id` as the short agent id and `fullId` as the key.
+ * Shared so ChatController and ChatApp stay aligned.
+ */
+function toInkAgentsDispatchList(snapshot = {}) {
+  const agents = Array.isArray(snapshot.agents) ? snapshot.agents : [];
+  return agents.map((row) => ({
+    ...row,
+    fullId: row.fullId || row.id,
+    id: row.agentId || row.id,
+    nickname: row.label || row.nickname,
+  }));
+}
+
 module.exports = {
   buildAgentMaps,
   getAgentLabel,
   resolveAgentId,
   resolveAgentDisplayName,
   clampAgentWindowWithSelection,
+  normalizeStatusToAgentsSnapshot,
+  toInkAgentsDispatchList,
 };

package/src/app/chat/agentEnter.js

@@ -0,0 +1,70 @@
+"use strict";
+
+/**
+ * Agent enter / dashboard navigation helpers (Phase 0B extraction).
+ */
+
+const path = require("path");
+
+function resolveInjectSockPathForAgent(projectRoot, agentId) {
+  const { getUfooPaths } = require("../../coordination/state/paths");
+  const { subscriberToSafeName } = require("../../coordination/bus/utils");
+  const safeName = subscriberToSafeName(agentId);
+  return path.join(getUfooPaths(projectRoot || process.cwd()).busQueuesDir, safeName, "inject.sock");
+}
+
+function resolveAgentEnterRequest({
+  agentId,
+  projectRoot = "",
+  activeAgentMeta = new Map(),
+  settings = {},
+} = {}) {
+  const id = String(agentId || "").trim();
+  if (!id) return null;
+
+  const metaMap = activeAgentMeta instanceof Map ? activeAgentMeta : new Map();
+  const meta = metaMap.get(id) || {};
+  const configuredLaunchMode = settings && settings.launchMode && settings.launchMode !== "auto"
+    ? settings.launchMode
+    : "";
+  const launchMode = String(meta.launch_mode || meta.launchMode || configuredLaunchMode || "").trim();
+  const { createTerminalAdapterRouter } = require("../../runtime/terminal/adapterRouter");
+  const adapter = createTerminalAdapterRouter().getAdapter({ launchMode, agentId: id, meta });
+  const caps = adapter && adapter.capabilities ? adapter.capabilities : {};
+
+  return {
+    agentId: id,
+    projectRoot: String(projectRoot || ""),
+    launchMode,
+    useBus: Boolean(caps.supportsInternalQueueLoop && !caps.supportsSocketProtocol),
+    supportsSocket: Boolean(caps.supportsSocketProtocol),
+    supportsInternalQueue: Boolean(caps.supportsInternalQueueLoop),
+    supportsActivate: Boolean(caps.supportsActivate),
+  };
+}
+
+function resolveDashboardAgentEnterAction(enterRequest = {}) {
+  if (!enterRequest || typeof enterRequest !== "object") return "none";
+  if (enterRequest.useBus) return "internal";
+  if (enterRequest.supportsActivate) return "activate";
+  // No PTY mirror fallback — host must expose activate (or use terminal/tmux/internal).
+  return "none";
+}
+
+function buildEmptyProjectsDownActions(state = {}, displayAgents = []) {
+  if (!state.emptyProjectsDownArmed) {
+    return [{ type: "projects/armEmptyDown" }];
+  }
+  const actions = [{ type: "view/set", view: "agents" }];
+  if (displayAgents.length > 0 && state.selectedAgentIndex < 0) {
+    actions.push({ type: "agents/select", index: 0 });
+  }
+  return actions;
+}
+
+module.exports = {
+  resolveInjectSockPathForAgent,
+  resolveAgentEnterRequest,
+  resolveDashboardAgentEnterAction,
+  buildEmptyProjectsDownActions,
+};

package/src/app/chat/agentIdentity.js

@@ -0,0 +1,50 @@
+"use strict";
+
+/**
+ * Agent label / id resolution for chat (Phase 0B extraction).
+ */
+
+function getAgentLabelFor(meta, agentId) {
+  if (meta && meta.display_nickname) return meta.display_nickname;
+  if (meta && meta.nickname) return meta.nickname;
+  if (!agentId) return "";
+  const colon = agentId.indexOf(":");
+  if (colon < 0) return agentId;
+  const head = agentId.slice(0, colon);
+  const tail = agentId.slice(colon + 1).slice(0, 6);
+  return tail ? `${head}:${tail}` : head;
+}
+
+function buildActiveAgentLabelMap(activeAgents = [], activeAgentMeta = new Map()) {
+  const out = new Map();
+  const metaMap = activeAgentMeta instanceof Map ? activeAgentMeta : new Map();
+  for (const id of Array.isArray(activeAgents) ? activeAgents : []) {
+    out.set(id, getAgentLabelFor(metaMap.get(id), id));
+  }
+  return out;
+}
+
+function resolveActiveAgentId(label, activeAgents = [], activeAgentMeta = new Map()) {
+  const { resolveAgentId } = require("./agentDirectory");
+  const metaMap = activeAgentMeta instanceof Map ? activeAgentMeta : new Map();
+  return resolveAgentId({
+    label,
+    activeAgents: Array.isArray(activeAgents) ? activeAgents : [],
+    labelMap: buildActiveAgentLabelMap(activeAgents, metaMap),
+    lookupNickname: (nickname) => {
+      for (const [id, meta] of metaMap.entries()) {
+        if (!meta) continue;
+        if (meta.nickname === nickname || meta.scoped_nickname === nickname || meta.display_nickname === nickname) {
+          return id;
+        }
+      }
+      return null;
+    },
+  });
+}
+
+module.exports = {
+  getAgentLabelFor,
+  buildActiveAgentLabelMap,
+  resolveActiveAgentId,
+};

package/src/app/chat/bootstrap.js

@@ -0,0 +1,66 @@
+"use strict";
+
+/**
+ * Chat bootstrap helpers (Phase 0B extraction from ChatApp).
+ * Headless — safe for ChatController and unit tests without Ink.
+ */
+
+const path = require("path");
+const fs = require("fs");
+const crypto = require("crypto");
+
+function bootstrapEnvironment(projectRoot, options = {}) {
+  const { canonicalProjectRoot } = require("../../runtime/projects");
+  const { getUfooPaths } = require("../../coordination/state/paths");
+  const UfooInit = require("../../app/cli/features/init");
+  const { isRunning } = require("../../runtime/daemon");
+  const { startDaemon } = require("../../app/chat/transport");
+
+  const globalMode = options && options.globalMode === true;
+  let activeProjectRoot = projectRoot;
+  try {
+    activeProjectRoot = canonicalProjectRoot(projectRoot);
+  } catch {
+    activeProjectRoot = path.resolve(projectRoot || process.cwd());
+  }
+
+  const runtimePaths = getUfooPaths(projectRoot);
+  const contextIndexFile = path.join(runtimePaths.ufooDir, "context", "decisions.jsonl");
+  const needsBootstrap = globalMode && (
+    !fs.existsSync(runtimePaths.ufooDir)
+    || !fs.existsSync(runtimePaths.busDir)
+    || !fs.existsSync(runtimePaths.agentDir)
+    || !fs.existsSync(contextIndexFile)
+  );
+
+  return {
+    activeProjectRoot,
+    globalMode,
+    runtimePaths,
+    needsBootstrap,
+    UfooInit,
+    isRunning,
+    startDaemon,
+  };
+}
+
+async function ensureSubscriberId(projectRoot) {
+  if (process.env.UFOO_SUBSCRIBER_ID) return;
+  const { getUfooPaths } = require("../../coordination/state/paths");
+  const sessionFile = path.join(getUfooPaths(projectRoot).ufooDir, "chat", "session-id.txt");
+  const sessionDir = path.dirname(sessionFile);
+  fs.mkdirSync(sessionDir, { recursive: true });
+  let sessionId;
+  if (fs.existsSync(sessionFile)) {
+    sessionId = fs.readFileSync(sessionFile, "utf8").trim();
+  } else {
+    sessionId = crypto.randomBytes(4).toString("hex");
+    fs.writeFileSync(sessionFile, sessionId, "utf8");
+  }
+  process.env.UFOO_SUBSCRIBER_ID = `claude-code:${sessionId}`;
+}
+
+module.exports = {
+  bootstrapEnvironment,
+  ensureSubscriberId,
+};