u-foo 1.9.0 → 1.9.2

package/SKILLS/ufoo/SKILL.md

@@ -24,14 +24,15 @@ When you see a probe marker command like `/ufoo <marker>` (Claude) or `$ufoo <ma
 
 ### When to Record
 
-**"If it has information value, write it down."**
+**"Only record decisions that matter beyond this session."**
 
-Record a decision whenever your work produces knowledge that would be useful to your future self, other agents, or the user. The threshold is LOW — when in doubt, record it.
+Record a decision for important, plan-level knowledge that other agents or your future self need. The threshold is HIGH — most tasks do NOT need a decision.
 
-- **Always record**: architectural choices, trade-off analysis, research findings, non-obvious gotchas, naming/convention changes, external API behavior discovered, performance observations, bug root causes
-- **Also record**: open questions you couldn't resolve, assumptions you made, approaches you considered and rejected (with reasons), edge cases noticed but not handled
+- **Always record**: architectural choices, plan-level decisions with multiple options, cross-agent coordination decisions, trade-off analysis where alternatives were considered and rejected
+- **Also record**: design patterns that set precedent, integration contracts between systems, decisions that constrain future work
+- **Do NOT record**: routine bug fixes, simple implementation details, trivial observations, findings that only matter within the current task
 - **Write the decision BEFORE acting on it** — if your session dies, the knowledge survives
-- **Granularity**: one sentence or multi-page analysis — match the depth to the information value
+- **Rule of thumb**: if another agent wouldn't need to know about it, don't write a decision
 
 ### Commands
 
@@ -121,7 +122,35 @@ Notes:
 
 ---
 
-## 3. Initialization (uinit)
+## 3. Message Format
+
+Bus messages use a unified prefix format to distinguish sources:
+
+- `[ufoo]<from:id(nickname)>` — message from another agent via the bus
+- `[manual]<to:id(nickname)>` — manual user input directed at an agent
+
+When you see `[ufoo]<from:xxx>` in your prompt, it's an inter-agent message — `xxx` is the sender's ID and nickname.
+When you see `[manual]<to:xxx>`, it's a direct user instruction to an agent — `xxx` is the recipient's ID and nickname.
+
+---
+
+## 4. Team Activity (Input History)
+
+Your bootstrap prompt may include a `## Team Activity` section showing recent prompts sent to all agents. Use this to understand:
+- What each agent is currently working on
+- Who sent what tasks to whom
+- The overall coordination flow
+
+Commands:
+```bash
+ufoo history build              # Rebuild timeline from bus + session data
+ufoo history show [limit]       # Show recent entries
+ufoo history prompt [limit]     # Render as injectable prompt block
+```
+
+---
+
+## 5. Initialization (uinit)
 
 Trigger: `/uinit` or `/ufoo init`
 

package/bin/ufoo.js

@@ -5,7 +5,7 @@ const { runDaemonCli } = require("../src/daemon/run");
 const { runChat } = require("../src/chat");
 const { runInternalRunner } = require("../src/agent/internalRunner");
 const { runPtyRunner } = require("../src/agent/ptyRunner");
-const { resolveGlobalControllerProjectRoot } = require("../src/globalMode");
+const { resolveGlobalControllerProjectRoot } = require("../src/projects");
 
 const rawArgv = process.argv.slice(2);
 

package/modules/bus/SKILLS/ubus/SKILL.md

@@ -102,15 +102,17 @@ If pending events exist, show:
 ```
 === Pending Messages ===
 
-@you from claude-code:abc123
-  Type: task/delegate
-  Content: {"task":"review","file":"src/main.ts"}
+[ufoo]<from:claude-code:abc123(architect)>
+  Type: message/targeted/message
+  Content: {"message":"review src/main.ts","injection_mode":"immediate"}
 
 ---
 Please handle the above messages, after completion you can reply:
-ufoo bus send "claude-code:abc123" "Review completed, found 2 issues..."
+ufoo bus send "architect" "Review completed, found 2 issues..."
 ```
 
+Note: Messages use `[ufoo]<from:id(nickname)>` prefix to distinguish from manual user input.
+
 ### 5. IMPORTANT: Acknowledge messages after handling
 
 After you have read and processed the messages, you MUST acknowledge them to prevent repeated notifications:

package/modules/context/SKILLS/uctx/SKILL.md

@@ -13,7 +13,8 @@ description: |
 Fast context check for daily use. Run at session start or anytime.
 
 Pre-flight reminder:
-- If the user is asking for evaluation/recommendation/plan, write a decision before replying.
+- If the user is asking for an important architectural decision, a plan with multiple options, or a cross-agent coordination choice, write a decision before replying.
+  Do NOT write decisions for routine tasks, simple bug fixes, or trivial findings.
   Use: `ufoo ctx decisions new "<Title>"`
 
 ## Decision format (canonical)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "u-foo",
-  "version": "1.9.0",
+  "version": "1.9.2",
   "description": "Multi-Agent Workspace Protocol. Just add u. claude → uclaude, codex → ucodex.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://ufoo.dev",

package/src/agent/defaultBootstrap.js

@@ -26,17 +26,40 @@ function hasMetaCommandArgs(args = []) {
   return hasArg(args, ["-h", "--help", "-v", "--version"]);
 }
 
-function buildDefaultStartupBootstrapPrompt({ agentType = "" } = {}) {
+/**
+ * Load the team activity timeline for prompt injection.
+ * The daemon syncs manual inputs every ~30s; bus messages are appended in real-time.
+ * Agent startup only reads — no build triggered here.
+ */
+function loadTeamActivityContext(projectRoot) {
+  try {
+    const { renderTimelineForPrompt } = require("../history/inputTimeline");
+    return renderTimelineForPrompt(projectRoot, 20) || "";
+  } catch {
+    return "";
+  }
+}
+
+function buildDefaultStartupBootstrapPrompt({ agentType = "", projectRoot = "" } = {}) {
   const normalizedAgent = asTrimmedString(agentType).toLowerCase();
   const displayAgent = normalizedAgent === "claude-code"
     ? "Claude"
     : (normalizedAgent === "codex" ? "Codex" : "agent");
-  return [
+
+  const segments = [
     `Session bootstrap for ${displayAgent}.`,
     "Adopt the following ufoo coordination protocol silently.",
     "Do not reply to this bootstrap message unless the user explicitly asks about it. After applying it, continue the active task or wait for user input.",
     SHARED_UFOO_PROTOCOL,
-  ].join("\n\n");
+  ];
+
+  const root = asTrimmedString(projectRoot) || process.cwd();
+  const teamActivity = loadTeamActivityContext(root);
+  if (teamActivity) {
+    segments.push(teamActivity);
+  }
+
+  return segments.join("\n\n");
 }
 
 function defaultBootstrapFile(projectRoot, agentType = "") {
@@ -78,7 +101,7 @@ function resolveDefaultManualBootstrap({
     if (hasArg(currentArgs, ["--append-system-prompt", "--system-prompt"])) {
       return { args: currentArgs, env: {}, mode: "skip" };
     }
-    const promptText = buildDefaultStartupBootstrapPrompt({ agentType: normalizedAgent });
+    const promptText = buildDefaultStartupBootstrapPrompt({ agentType: normalizedAgent, projectRoot });
     const prepared = prepareDefaultBootstrapFile({
       projectRoot,
       agentType: normalizedAgent,
@@ -97,7 +120,7 @@ function resolveDefaultManualBootstrap({
     if (currentArgs.length > 0) {
       return { args: currentArgs, env: {}, mode: "skip" };
     }
-    const promptText = buildDefaultStartupBootstrapPrompt({ agentType: normalizedAgent });
+    const promptText = buildDefaultStartupBootstrapPrompt({ agentType: normalizedAgent, projectRoot });
     return {
       args: currentArgs,
       env: {

package/src/agent/ufooAgent.js

@@ -11,8 +11,7 @@ const {
 } = require("../code/nativeRunner");
 const { DEFAULT_ASSISTANT_TIMEOUT_MS } = require("../assistant/constants");
 const { normalizeAgentTypeAlias } = require("../bus/utils");
-const { listProjectRuntimes } = require("../projects/registry");
-const { isGlobalControllerProjectRoot } = require("../globalMode");
+const { listProjectRuntimes, isGlobalControllerProjectRoot } = require("../projects");
 
 function loadSessionState(projectRoot) {
   const dir = getUfooPaths(projectRoot).agentDir;

package/src/bus/daemon.js

@@ -19,17 +19,21 @@ function isBusyActivityState(value = "") {
  * Bus Daemon - 监控消息并自动注入命令
  */
 class BusDaemon {
-  constructor(busDir, agentsFile, daemonDir, interval = 2000) {
+  constructor(busDir, agentsFile, daemonDir, interval = 2000, projectRoot = "") {
     this.busDir = busDir;
     this.agentsFile = agentsFile;
     this.interval = interval;
     this.daemonDir = daemonDir;
+    this.projectRoot = projectRoot || path.resolve(busDir, "..", "..");
     this.pidFile = path.join(this.daemonDir, "daemon.pid");
     this.logFile = path.join(this.daemonDir, "daemon.log");
     this.countsDir = path.join(this.daemonDir, "counts", `${process.pid}`);
     this.running = false;
     this.cleanupCounter = 0;
     this.cleanupInterval = 5; // 每 5 个周期清理一次
+    this.timelineSyncCounter = 0;
+    // 每 15 个周期同步一次 manual inputs (~15 × interval, default ~30s)
+    this.timelineSyncInterval = 15;
 
     this.queueManager = new QueueManager(busDir);
     this.injector = new Injector(busDir, agentsFile);
@@ -233,6 +237,13 @@ class BusDaemon {
           this.cleanupCounter = 0;
         }
 
+        // 定期同步 timeline（manual inputs from session files, ~15 × interval）
+        this.timelineSyncCounter++;
+        if (this.timelineSyncCounter >= this.timelineSyncInterval) {
+          this.syncTimeline();
+          this.timelineSyncCounter = 0;
+        }
+
         // 检查所有订阅者的队列
         await this.checkQueues();
       } catch (err) {
@@ -244,6 +255,20 @@ class BusDaemon {
     }
   }
 
+  /**
+   * 增量同步 timeline — 捕获 manual inputs（bus 消息已在 send() 时实时追加）
+   */
+  syncTimeline() {
+    try {
+      const { buildTimeline } = require("../history/inputTimeline");
+      buildTimeline(this.projectRoot);
+    } catch (err) {
+      if (process.env.UFOO_HISTORY_DEBUG === "1") {
+        console.error("[daemon][history] syncTimeline failed:", err.message);
+      }
+    }
+  }
+
   /**
    * 检查所有队列
    */

package/src/bus/index.js

@@ -328,6 +328,23 @@ class EventBus {
           `Event sent: event=${eventName} seq=${result.seq} -> ${result.targets.join(", ")}`
         );
       }
+
+      // Real-time timeline append for message events
+      if (eventName === "message" && message) {
+        try {
+          const { appendBusEntry } = require("../history/inputTimeline");
+          appendBusEntry(this.projectRoot, {
+            seq: result.seq,
+            timestamp: new Date().toISOString(),
+            publisher,
+            target,
+            message,
+          });
+        } catch {
+          // non-critical
+        }
+      }
+
       return result;
     } catch (err) {
       logError(err.message);
@@ -364,7 +381,10 @@ class EventBus {
     console.log();
 
     for (const event of pending) {
-      console.log(`  ${colors.yellow}@you${colors.reset} from ${colors.cyan}${event.publisher}${colors.reset}`);
+      const publisherMeta = this.busData.agents?.[event.publisher];
+      const nick = publisherMeta?.nickname;
+      const fromLabel = nick ? `${event.publisher}(${nick})` : event.publisher;
+      console.log(`  ${colors.yellow}[ufoo]<from:${fromLabel}>${colors.reset}`);
       console.log(`  Type: ${event.type}/${event.event}`);
       console.log(`  Content: ${JSON.stringify(event.data)}`);
       console.log();
@@ -731,7 +751,7 @@ class EventBus {
 
       if (countAfter > countBefore) {
         await sleep(50);
-        const daemon = new BusDaemon(this.busDir, this.agentsFile, this.paths.busDaemonDir, 2000);
+        const daemon = new BusDaemon(this.busDir, this.agentsFile, this.paths.busDaemonDir, 2000, this.projectRoot);
         await daemon.injector.inject(target, options.command || "");
         if (options.shake !== false) {
           const tty = daemon.injector.readTty(target);
@@ -829,7 +849,7 @@ class EventBus {
    */
   async daemon(action, options = {}) {
     const interval = options.interval || 2000;
-    const daemon = new BusDaemon(this.busDir, this.agentsFile, this.paths.busDaemonDir, interval);
+    const daemon = new BusDaemon(this.busDir, this.agentsFile, this.paths.busDaemonDir, interval, this.projectRoot);
 
     switch (action) {
       case "start":

package/src/chat/commandExecutor.js

@@ -6,7 +6,7 @@ const { runGroupCoreCommand } = require("../cli/groupCoreCommands");
 const { loadConfig: loadProjectConfig, saveConfig: saveProjectConfig, loadGlobalUcodeConfig, saveGlobalUcodeConfig } = require("../config");
 const { resolveTransport } = require("../code/nativeRunner");
 const { parseIntervalMs, formatIntervalMs } = require("./cronScheduler");
-const { isGlobalControllerProjectRoot, resolveGlobalControllerUfooDir } = require("../globalMode");
+const { isGlobalControllerProjectRoot, resolveGlobalControllerUfooDir } = require("../projects");
 const { loadPromptProfileRegistry } = require("../group/promptProfiles");
 const { resolveSoloAgentType } = require("../solo/commands");
 

package/src/chat/index.js

@@ -44,15 +44,18 @@ const { createDaemonCoordinator } = require("./daemonCoordinator");
 const { IPC_REQUEST_TYPES } = require("../shared/eventContract");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonTransport } = require("./daemonTransport");
-const { listProjectRuntimes, resolveRuntimeDir } = require("../projects/registry");
-const { canonicalProjectRoot, buildProjectId } = require("../projects/projectId");
-const { loadTemplateRegistry } = require("../group/templates");
 const {
+  listProjectRuntimes,
+  resolveRuntimeDir,
+  canonicalProjectRoot,
+  buildProjectId,
   sortProjectRuntimes,
   parseTimestampMs,
   filterVisibleProjectRuntimes,
-} = require("./projectRuntimes");
-const { isGlobalControllerProjectRoot, resolveGlobalControllerProjectRoot } = require("../globalMode");
+  isGlobalControllerProjectRoot,
+  resolveGlobalControllerProjectRoot,
+} = require("../projects");
+const { loadTemplateRegistry } = require("../group/templates");
 const {
   DEFAULT_TRANSIENT_AGENT_STATE_TTL_MS,
   setTransientAgentState: setTransientAgentStateValue,

package/src/cli.js

@@ -1327,6 +1327,38 @@ async function runCli(argv) {
         }
       });
 
+    const history = program.command("history").description("Agent input history timeline");
+    history
+      .command("build")
+      .description("Build unified input timeline (incremental by default)")
+      .option("--force", "Full rebuild (ignore watermark)")
+      .action((opts) => {
+        const { buildTimeline } = require("./history/inputTimeline");
+        const result = buildTimeline(process.cwd(), { force: opts.force === true });
+        console.log(`Timeline: ${result.count} total, ${result.newCount} new → ${result.file}`);
+      });
+    history
+      .command("show")
+      .description("Show recent timeline entries")
+      .argument("[limit]", "Number of entries to show", "50")
+      .action((limit) => {
+        const { showTimeline } = require("./history/inputTimeline");
+        showTimeline(process.cwd(), parseInt(limit, 10) || 50);
+      });
+    history
+      .command("prompt")
+      .description("Render timeline as injectable prompt context")
+      .argument("[limit]", "Number of entries to include", "30")
+      .action((limit) => {
+        const { renderTimelineForPrompt } = require("./history/inputTimeline");
+        const text = renderTimelineForPrompt(process.cwd(), parseInt(limit, 10) || 30);
+        if (text) {
+          console.log(text);
+        } else {
+          console.log("No timeline data. Run `ufoo history build` first.");
+        }
+      });
+
     program.addHelpText(
       "after",
       `\nNotes:\n  - If 'ufoo' isn't in PATH, run it via ${chalk.cyan(
@@ -1391,6 +1423,7 @@ async function runCli(argv) {
     console.log("  ufoo bus wake <target> [--reason <reason>] [--no-shake]");
     console.log("  ufoo bus <args...>    (JS bus implementation)");
     console.log("  ufoo ctx <subcmd> ... (doctor|lint|decisions|sync)");
+    console.log("  ufoo history <build|show|prompt> [limit]");
     console.log("");
     console.log("Notes:");
     console.log("  - For Codex notifications, use ufoo bus alert / ufoo bus listen");
@@ -2099,6 +2132,36 @@ async function runCli(argv) {
     return;
   }
 
+  if (cmd === "history") {
+    const sub = rest[0] || "show";
+    const cwd = process.cwd();
+    const { buildTimeline, showTimeline, renderTimelineForPrompt } = require("./history/inputTimeline");
+
+    if (sub === "build") {
+      const force = rest.includes("--force");
+      const result = buildTimeline(cwd, { force });
+      console.log(`Timeline: ${result.count} total, ${result.newCount} new → ${result.file}`);
+      return;
+    }
+    if (sub === "show") {
+      const limit = parseInt(rest[1], 10) || 50;
+      showTimeline(cwd, limit);
+      return;
+    }
+    if (sub === "prompt") {
+      const limit = parseInt(rest[1], 10) || 30;
+      const text = renderTimelineForPrompt(cwd, limit);
+      if (text) {
+        console.log(text);
+      } else {
+        console.log("No timeline data. Run `ufoo history build` first.");
+      }
+      return;
+    }
+    console.log("Usage: ufoo history [build|show|prompt] [limit]");
+    return;
+  }
+
   help();
   process.exitCode = 1;
 }

package/src/daemon/index.js

@@ -12,7 +12,7 @@ const { generateInstanceId, subscriberToSafeName } = require("../bus/utils");
 const { createDaemonIpcServer } = require("./ipcServer");
 const { IPC_REQUEST_TYPES, IPC_RESPONSE_TYPES, BUS_STATUS_PHASES } = require("../shared/eventContract");
 const { getUfooPaths } = require("../ufoo/paths");
-const { upsertProjectRuntime, markProjectStopped } = require("../projects/registry");
+const { upsertProjectRuntime, markProjectStopped } = require("../projects");
 const { scheduleProviderSessionProbe, resolveSessionFromFile, persistProviderSession, loadProviderSessionCache } = require("./providerSessions");
 const { createTerminalAdapterRouter } = require("../terminal/adapterRouter");
 const { createDaemonCronController } = require("./cronOps");
@@ -22,7 +22,7 @@ const { runAssistantTask } = require("../assistant/bridge");
 const { runPromptWithAssistant } = require("./promptLoop");
 const { handlePromptRequest } = require("./promptRequest");
 const { recordAgentReport } = require("./reporting");
-const { isGlobalControllerProjectRoot } = require("../globalMode");
+const { isGlobalControllerProjectRoot } = require("../projects");
 const {
   assignSoloRoleToExistingAgent,
   resolveSoloPromptProfile,
@@ -2071,43 +2071,61 @@ function startDaemon({ projectRoot, provider, model, resumeMode = "auto" }) {
       }
       log(`agent_ready id=${subscriberId} pid=${agentPid || 0} - resolving session`);
 
-      // Try direct file read first if we have agentPid (fast path)
       const parsedAgentPid = Number.parseInt(agentPid, 10);
-      if (Number.isFinite(parsedAgentPid) && parsedAgentPid > 0) {
-        const agentType = subscriberId.split(":")[0] || "";
-        const resolved = resolveSessionFromFile(agentType, {
-          pid: parsedAgentPid,
-          cwd: projectRoot,
-        });
-        if (resolved && resolved.sessionId) {
-          log(`agent_ready session resolved from file for ${subscriberId}: ${resolved.sessionId}`);
-          persistProviderSession(projectRoot, subscriberId, resolved);
-          if (providerSessions) {
-            providerSessions.set(subscriberId, {
-              sessionId: resolved.sessionId,
-              source: resolved.source || "",
-              updated_at: new Date().toISOString(),
-            });
+      const agentType = subscriberId.split(":")[0] || "";
+
+      // In _spawnDirect (host mode), AGENT_READY is sent immediately after
+      // spawn() before Claude has written ~/.claude/sessions/<pid>.json.
+      // Retry with short backoff to handle the race condition.
+      const RETRY_DELAYS_MS = [100, 500, 1000, 2000, 3000];
+
+      const tryResolveSession = (attempt) => {
+        if (Number.isFinite(parsedAgentPid) && parsedAgentPid > 0) {
+          const resolved = resolveSessionFromFile(agentType, {
+            pid: parsedAgentPid,
+            cwd: projectRoot,
+          });
+          if (resolved && resolved.sessionId) {
+            const attemptNote = attempt > 1 ? ` (attempt ${attempt})` : "";
+            log(`agent_ready session resolved from file for ${subscriberId}: ${resolved.sessionId}${attemptNote}`);
+            persistProviderSession(projectRoot, subscriberId, resolved);
+            if (providerSessions) {
+              providerSessions.set(subscriberId, {
+                sessionId: resolved.sessionId,
+                source: resolved.source || "",
+                updated_at: new Date().toISOString(),
+              });
+            }
+            // Cancel the scheduled probe to prevent redundant /ufoo injection
+            const handle = probeHandles.get(subscriberId);
+            if (handle && typeof handle.cancel === "function") {
+              handle.cancel();
+            }
+            probeHandles.delete(subscriberId);
+            return;
           }
-          // Cancel the scheduled probe to prevent /ufoo injection
-          const handle = probeHandles.get(subscriberId);
-          if (handle && typeof handle.cancel === "function") {
-            handle.cancel();
+
+          // Session file not ready — retry if attempts remain
+          const delayMs = RETRY_DELAYS_MS[attempt - 1];
+          if (delayMs !== undefined) {
+            setTimeout(() => tryResolveSession(attempt + 1), delayMs);
+            return;
           }
-          probeHandles.delete(subscriberId);
-          return;
         }
-      }
 
-      // Fallback: trigger scheduled probe
-      const probeHandle = probeHandles.get(subscriberId);
-      if (probeHandle && typeof probeHandle.triggerNow === "function") {
-        probeHandle.triggerNow().catch((err) => {
-          log(`agent_ready probe trigger failed for ${subscriberId}: ${err.message}`);
-        });
-      } else {
-        log(`agent_ready no probe handle found for ${subscriberId}`);
-      }
+        // Exhausted retries or no pid — fall back to scheduled probe
+        const probeHandle = probeHandles.get(subscriberId);
+        if (probeHandle && typeof probeHandle.triggerNow === "function") {
+          log(`agent_ready falling back to probe for ${subscriberId}`);
+          probeHandle.triggerNow().catch((err) => {
+            log(`agent_ready probe trigger failed for ${subscriberId}: ${err.message}`);
+          });
+        } else {
+          log(`agent_ready no probe handle found for ${subscriberId}`);
+        }
+      };
+
+      tryResolveSession(1);
       return;
     }
   };

package/src/daemon/promptRequest.js

@@ -5,7 +5,7 @@ const {
   listControllerInboxEntries,
   consumeControllerInboxEntries,
 } = require("../report/store");
-const { isGlobalControllerProjectRoot } = require("../globalMode");
+const { isGlobalControllerProjectRoot } = require("../projects");
 
 function normalizeProjectRoute(route) {
   if (!route || typeof route !== "object") return null;

package/src/group/bootstrap.js

@@ -5,7 +5,7 @@ const crypto = require("crypto");
 const SHARED_UFOO_PROTOCOL = [
   "ufoo protocol:",
   "- At session start, sync shared context with `ufoo ctx decisions -l` and `ufoo ctx decisions -n 1`.",
-  "- If your work produces knowledge with information value, record it before acting via `ufoo ctx decisions new \"Title\"`.",
+  "- Record a decision ONLY for important, plan-level knowledge: architectural choices, multi-option trade-off analysis, cross-agent coordination decisions, or plans that affect other agents. Do NOT record routine findings, simple bug fixes, or trivial observations. Use `ufoo ctx decisions new \"Title\"` BEFORE acting.",
   "- Use `ufoo bus send <target-nickname> \"<message>\"` for agent-to-agent handoffs.",
   "- If you receive pending bus work, execute it immediately, reply to the sender, then `ufoo bus ack \"$UFOO_SUBSCRIBER_ID\"`.",
   "- Use `ufoo report` for controller/runtime status updates, not as a substitute for direct handoffs.",

package/src/history/inputTimeline.js

@@ -0,0 +1,601 @@
+"use strict";
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const { getUfooPaths } = require("../ufoo/paths");
+const { loadAgentsData } = require("../ufoo/agentsStore");
+
+const HISTORY_DEBUG = process.env.UFOO_HISTORY_DEBUG === "1";
+const debugLog = (...args) => { if (HISTORY_DEBUG) console.error("[history]", ...args); };
+
+/**
+ * Input Timeline — aggregates all agent inputs into a unified chat-like history.
+ *
+ * Sources:
+ * 1. Bus events (message/targeted) — inter-agent messages, appended in real-time
+ * 2. Claude ​Code session JSONL — manual user inputs, synced by daemon every ~30s
+ * 3. Codex session rollout files — manual user inputs, synced by daemon every ~30s
+ *
+ * Incremental builds use a watermark file tracking:
+ * - busLastSeq: last processed bus event seq number
+ * - lastTs: last processed timestamp (used to skip session file records + mtime filter)
+ * - entryCount: maintained count (avoids full-scan just to count)
+ * - builtAt: when last build ran
+ *
+ * Output format (JSONL per entry):
+ * {
+ *   ts: ISO timestamp,
+ *   source: "bus" | "manual",
+ *   from: display label (nickname or "user"),
+ *   fromId: subscriber ID or "user",
+ *   to: display label,
+ *   toId: subscriber ID or "",
+ *   message: string
+ * }
+ */
+
+// ---------------------------------------------------------------------------
+// Paths (all derived from getUfooPaths to avoid hardcoding)
+// ---------------------------------------------------------------------------
+
+function getHistoryDir(projectRoot) {
+  return getUfooPaths(projectRoot).historyDir;
+}
+
+function getTimelineFile(projectRoot) {
+  return path.join(getHistoryDir(projectRoot), "input-timeline.jsonl");
+}
+
+function getWatermarkFile(projectRoot) {
+  return path.join(getHistoryDir(projectRoot), "watermark.json");
+}
+
+// ---------------------------------------------------------------------------
+// Watermark
+// ---------------------------------------------------------------------------
+
+const WATERMARK_LOCK_STALE_MS = 10000;
+
+function readWatermark(projectRoot) {
+  try {
+    const file = getWatermarkFile(projectRoot);
+    if (fs.existsSync(file)) {
+      return JSON.parse(fs.readFileSync(file, "utf8"));
+    }
+  } catch {
+    // corrupted — treat as fresh
+  }
+  return { busLastSeq: 0, lastTs: "", entryCount: 0 };
+}
+
+/**
+ * Synchronous non-blocking file lock for watermark writes.
+ * Returns lock handle on success, null if lock is held (caller skips update).
+ */
+function acquireWatermarkLock(projectRoot) {
+  const lockFile = path.join(getHistoryDir(projectRoot), "watermark.lock");
+  try {
+    const fd = fs.openSync(lockFile, "wx");
+    fs.writeSync(fd, `${process.pid}\n`);
+    return { fd, lockFile };
+  } catch (err) {
+    if (err && err.code === "EEXIST") {
+      try {
+        const stat = fs.statSync(lockFile);
+        if (Date.now() - stat.mtimeMs > WATERMARK_LOCK_STALE_MS) {
+          fs.unlinkSync(lockFile);
+          const fd = fs.openSync(lockFile, "wx");
+          fs.writeSync(fd, `${process.pid}\n`);
+          return { fd, lockFile };
+        }
+      } catch {
+        // give up
+      }
+    }
+    return null;
+  }
+}
+
+function releaseWatermarkLock(lock) {
+  if (!lock) return;
+  try { fs.closeSync(lock.fd); } catch { /* ignore */ }
+  try { fs.unlinkSync(lock.lockFile); } catch { /* ignore */ }
+}
+
+function writeWatermark(projectRoot, watermark) {
+  fs.mkdirSync(getHistoryDir(projectRoot), { recursive: true });
+  fs.writeFileSync(getWatermarkFile(projectRoot), JSON.stringify(watermark, null, 2) + "\n", "utf8");
+}
+
+// ---------------------------------------------------------------------------
+// JSONL helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Stream-parse a JSONL file line by line.
+ * Calls fn(record) for each valid line; stops early if fn returns false.
+ */
+function streamJSONL(filePath, fn) {
+  if (!fs.existsSync(filePath)) return;
+  const raw = fs.readFileSync(filePath, "utf8");
+  let start = 0;
+  while (start < raw.length) {
+    let end = raw.indexOf("\n", start);
+    if (end === -1) end = raw.length;
+    const line = raw.slice(start, end).trim();
+    start = end + 1;
+    if (!line) continue;
+    try {
+      const record = JSON.parse(line);
+      if (fn(record) === false) return;
+    } catch {
+      // skip malformed
+    }
+  }
+}
+
+/**
+ * Read the last N records from a JSONL file (tail-read, avoids full load).
+ */
+function readTailJSONL(filePath, limit = 50) {
+  if (!fs.existsSync(filePath)) return [];
+  const stat = fs.statSync(filePath);
+  if (stat.size === 0) return [];
+
+  if (stat.size < 512 * 1024) {
+    const results = [];
+    streamJSONL(filePath, (r) => { results.push(r); });
+    return results.slice(-limit);
+  }
+
+  const chunkSize = Math.min(stat.size, limit * 2048);
+  const buf = Buffer.alloc(chunkSize);
+  const fd = fs.openSync(filePath, "r");
+  try {
+    const offset = Math.max(0, stat.size - chunkSize);
+    fs.readSync(fd, buf, 0, chunkSize, offset);
+    const lines = buf.toString("utf8").split(/\r?\n/).filter(Boolean);
+    const startIdx = offset > 0 ? 1 : 0; // skip possible partial first line
+    const results = [];
+    for (let i = startIdx; i < lines.length; i++) {
+      try { results.push(JSON.parse(lines[i])); } catch { /* skip */ }
+    }
+    return results.slice(-limit);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Lookups
+// ---------------------------------------------------------------------------
+
+function buildNicknameLookup(projectRoot) {
+  const data = loadAgentsData(getUfooPaths(projectRoot).agentsFile);
+  const lookup = new Map();
+  for (const [id, meta] of Object.entries(data.agents || {})) {
+    if (meta && meta.nickname) lookup.set(id, meta.nickname);
+  }
+  return lookup;
+}
+
+function buildSessionLookup(projectRoot) {
+  const data = loadAgentsData(getUfooPaths(projectRoot).agentsFile);
+  const lookup = new Map();
+  for (const [id, meta] of Object.entries(data.agents || {})) {
+    if (meta && meta.provider_session_id) {
+      lookup.set(meta.provider_session_id, {
+        subscriberId: id,
+        nickname: meta.nickname || id,
+      });
+    }
+  }
+  return lookup;
+}
+
+/**
+ * Derive the Claude projects directory for this project root.
+ * Claude stores sessions at: ~/.claude/projects/<path-with-dashes>/<sessionId>.jsonl
+ */
+function getClaudeProjectDir(projectRoot) {
+  const slug = path.resolve(projectRoot).replace(/\//g, "-");
+  return path.join(os.homedir(), ".claude", "projects", slug);
+}
+
+// ---------------------------------------------------------------------------
+// Text extraction helpers
+// ---------------------------------------------------------------------------
+
+function extractUserText(record) {
+  const msg = record.message;
+  if (!msg || typeof msg !== "object") return "";
+  const content = msg.content;
+  if (typeof content === "string") return content.replace(/<[^>]+>/g, "").trim();
+  if (Array.isArray(content)) {
+    return content
+      .map((c) => (typeof c === "string" ? c : c && c.text ? c.text : ""))
+      .join("")
+      .replace(/<[^>]+>/g, "")
+      .trim();
+  }
+  return "";
+}
+
+function isProbeMarker(text) {
+  return /^\/ufoo\s+\S+$/.test(text) || /^\$ufoo\s+\S+$/.test(text);
+}
+
+// ---------------------------------------------------------------------------
+// Collectors
+// ---------------------------------------------------------------------------
+
+/**
+ * Collect new bus events since watermark.busLastSeq.
+ * Skips event files whose date is strictly before the watermark date.
+ */
+function collectBusMessages(projectRoot, watermark = {}) {
+  const eventsDir = getUfooPaths(projectRoot).busEventsDir;
+  if (!fs.existsSync(eventsDir)) return { entries: [], maxSeq: watermark.busLastSeq || 0 };
+
+  const minSeq = watermark.busLastSeq || 0;
+  const nicknames = buildNicknameLookup(projectRoot);
+  const entries = [];
+  let maxSeq = minSeq;
+  const watermarkDate = watermark.lastTs ? watermark.lastTs.slice(0, 10) : "";
+
+  const files = fs.readdirSync(eventsDir).filter((f) => f.endsWith(".jsonl")).sort();
+  for (const file of files) {
+    if (watermarkDate && file < `${watermarkDate}.jsonl`) continue;
+    streamJSONL(path.join(eventsDir, file), (evt) => {
+      if (!evt.seq || evt.seq <= minSeq) return;
+      if (evt.type !== "message/targeted" || evt.event !== "message") return;
+      if (!evt.data || !evt.data.message) return;
+      if (evt.seq > maxSeq) maxSeq = evt.seq;
+      entries.push({
+        ts: evt.timestamp,
+        source: "bus",
+        from: nicknames.get(evt.publisher) || evt.publisher,
+        fromId: evt.publisher,
+        to: nicknames.get(evt.target) || evt.target,
+        toId: evt.target,
+        message: evt.data.message,
+      });
+    });
+  }
+
+  return { entries, maxSeq };
+}
+
+/**
+ * Collect new manual user inputs from Claude ​Code session files.
+ * Uses mtime to skip unmodified files; within modified files filters by timestamp.
+ */
+function collectClaudeManualInputs(projectRoot, watermark = {}) {
+  const claudeProjectDir = getClaudeProjectDir(projectRoot);
+  if (!fs.existsSync(claudeProjectDir)) return [];
+
+  const sessionLookup = buildSessionLookup(projectRoot);
+  const entries = [];
+  const cutoffMs = watermark.lastTs ? new Date(watermark.lastTs).getTime() : 0;
+
+  const sessionToAgent = new Map();
+  for (const [sessionId, info] of sessionLookup) {
+    if (info.subscriberId.startsWith("claude-code:")) {
+      sessionToAgent.set(sessionId, info);
+    }
+  }
+
+  let sessionFiles;
+  if (sessionToAgent.size > 0) {
+    sessionFiles = [];
+    for (const sessionId of sessionToAgent.keys()) {
+      const filePath = path.join(claudeProjectDir, `${sessionId}.jsonl`);
+      if (fs.existsSync(filePath)) sessionFiles.push({ filePath, sessionId });
+    }
+  } else {
+    try {
+      sessionFiles = fs.readdirSync(claudeProjectDir)
+        .filter((f) => f.endsWith(".jsonl"))
+        .map((f) => ({ filePath: path.join(claudeProjectDir, f), sessionId: f.replace(".jsonl", "") }));
+    } catch {
+      return entries;
+    }
+  }
+
+  for (const { filePath, sessionId } of sessionFiles) {
+    if (cutoffMs > 0) {
+      try {
+        if (fs.statSync(filePath).mtimeMs <= cutoffMs) continue;
+      } catch { continue; }
+    }
+
+    const agent = sessionToAgent.get(sessionId);
+    const toLabel = agent ? agent.nickname : `session:${sessionId.slice(0, 8)}`;
+    const toId = agent ? agent.subscriberId : "";
+
+    streamJSONL(filePath, (record) => {
+      if (record.type !== "user") return;
+      if (cutoffMs > 0 && record.timestamp) {
+        if (new Date(record.timestamp).getTime() <= cutoffMs) return;
+      }
+      const text = extractUserText(record);
+      if (!text || isProbeMarker(text)) return;
+      entries.push({
+        ts: record.timestamp || "",
+        source: "manual",
+        from: "user",
+        fromId: "user",
+        to: toLabel,
+        toId,
+        message: text,
+      });
+    });
+  }
+
+  return entries;
+}
+
+/**
+ * Collect new manual user inputs from Codex session rollouts.
+ * Skips date directories older than watermark date; skips files by mtime.
+ */
+function collectCodexManualInputs(projectRoot, watermark = {}) {
+  const sessionLookup = buildSessionLookup(projectRoot);
+  if (sessionLookup.size === 0) return [];
+
+  const entries = [];
+  const sessionsBase = path.join(os.homedir(), ".codex", "sessions");
+  if (!fs.existsSync(sessionsBase)) return entries;
+
+  const cutoffMs = watermark.lastTs ? new Date(watermark.lastTs).getTime() : 0;
+  const cutoffDate = watermark.lastTs ? watermark.lastTs.slice(0, 10) : "";
+
+  const codexSessions = new Map();
+  for (const [sessionId, info] of sessionLookup) {
+    if (info.subscriberId.startsWith("codex:")) codexSessions.set(sessionId, info);
+  }
+  if (codexSessions.size === 0) return entries;
+
+  let years;
+  try { years = fs.readdirSync(sessionsBase).filter((d) => /^\d{4}$/.test(d)); } catch { return entries; }
+
+  for (const y of years) {
+    if (cutoffDate && y < cutoffDate.slice(0, 4)) continue;
+    const yDir = path.join(sessionsBase, y);
+    let months;
+    try { months = fs.readdirSync(yDir).filter((d) => /^\d{2}$/.test(d)); } catch { continue; }
+    for (const m of months) {
+      if (cutoffDate && `${y}-${m}` < cutoffDate.slice(0, 7)) continue;
+      const mDir = path.join(yDir, m);
+      let days;
+      try { days = fs.readdirSync(mDir).filter((d) => /^\d{2}$/.test(d)); } catch { continue; }
+      for (const d of days) {
+        if (cutoffDate && `${y}-${m}-${d}` < cutoffDate) continue;
+        const dDir = path.join(mDir, d);
+        let files;
+        try {
+          files = fs.readdirSync(dDir).filter((f) => f.startsWith("rollout-") && f.endsWith(".jsonl"));
+        } catch { continue; }
+
+        for (const file of files) {
+          const filePath = path.join(dDir, file);
+          if (cutoffMs > 0) {
+            try { if (fs.statSync(filePath).mtimeMs <= cutoffMs) continue; } catch { continue; }
+          }
+
+          let sessionId = "";
+          streamJSONL(filePath, (rec) => {
+            if (rec.type === "session_meta" && rec.payload?.id) {
+              sessionId = rec.payload.id;
+              return false;
+            }
+          });
+
+          const agent = codexSessions.get(sessionId);
+          if (!agent) continue;
+
+          streamJSONL(filePath, (rec) => {
+            if (rec.type !== "message" || rec.role !== "user") return;
+            if (cutoffMs > 0 && rec.timestamp) {
+              if (new Date(rec.timestamp).getTime() <= cutoffMs) return;
+            }
+            const content = typeof rec.content === "string"
+              ? rec.content
+              : Array.isArray(rec.content)
+                ? rec.content.map((c) => c.text || "").join("")
+                : "";
+            if (!content) return;
+            entries.push({
+              ts: rec.timestamp ? new Date(rec.timestamp).toISOString() : new Date().toISOString(),
+              source: "manual",
+              from: "user",
+              fromId: "user",
+              to: agent.nickname,
+              toId: agent.subscriberId,
+              message: content,
+            });
+          });
+        }
+      }
+    }
+  }
+
+  return entries;
+}
+
+// ---------------------------------------------------------------------------
+// Real-time append (called from EventBus.send)
+// ---------------------------------------------------------------------------
+
+/**
+ * Append a single bus message to the timeline immediately on send.
+ * Uses file lock to safely advance the watermark; if lock is contended,
+ * skips the watermark update (next build will catch up — no data lost).
+ */
+function appendBusEntry(projectRoot, { seq, timestamp, publisher, target, message, nicknames = null }) {
+  try {
+    fs.mkdirSync(getHistoryDir(projectRoot), { recursive: true });
+    const timelineFile = getTimelineFile(projectRoot);
+
+    const nicknameMap = nicknames || buildNicknameLookup(projectRoot);
+    const entry = {
+      ts: timestamp,
+      source: "bus",
+      from: nicknameMap.get(publisher) || publisher,
+      fromId: publisher,
+      to: nicknameMap.get(target) || target,
+      toId: target,
+      message,
+    };
+
+    fs.appendFileSync(timelineFile, JSON.stringify(entry) + "\n", "utf8");
+
+    if (seq) {
+      const lock = acquireWatermarkLock(projectRoot);
+      if (lock) {
+        try {
+          const watermark = readWatermark(projectRoot);
+          if (seq > (watermark.busLastSeq || 0)) {
+            watermark.busLastSeq = seq;
+            if (timestamp && (!watermark.lastTs || timestamp > watermark.lastTs)) {
+              watermark.lastTs = timestamp;
+            }
+            watermark.entryCount = (watermark.entryCount || 0) + 1;
+            writeWatermark(projectRoot, watermark);
+          }
+        } finally {
+          releaseWatermarkLock(lock);
+        }
+      }
+      // lock contended → watermark update skipped; next build will reprocess
+    }
+  } catch (err) {
+    debugLog("appendBusEntry failed:", err.message);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Incremental build
+// ---------------------------------------------------------------------------
+
+/**
+ * Build the timeline incrementally (or fully with force=true).
+ * Reads watermark → collects only new entries → appends → updates watermark.
+ * entryCount is maintained in the watermark to avoid full-file counting.
+ */
+function buildTimeline(projectRoot, { force = false } = {}) {
+  fs.mkdirSync(getHistoryDir(projectRoot), { recursive: true });
+  const timelineFile = getTimelineFile(projectRoot);
+
+  const watermark = force ? { busLastSeq: 0, lastTs: "", entryCount: 0 } : readWatermark(projectRoot);
+
+  const busResult = collectBusMessages(projectRoot, watermark);
+  const claudeEntries = collectClaudeManualInputs(projectRoot, watermark);
+  const codexEntries = collectCodexManualInputs(projectRoot, watermark);
+
+  const newEntries = [...busResult.entries, ...claudeEntries, ...codexEntries];
+  newEntries.sort((a, b) => new Date(a.ts).getTime() - new Date(b.ts).getTime());
+
+  if (newEntries.length === 0 && !force) {
+    return { count: watermark.entryCount || 0, newCount: 0, file: timelineFile };
+  }
+
+  const lock = acquireWatermarkLock(projectRoot);
+  try {
+    if (force) {
+      const content = newEntries.map((e) => JSON.stringify(e)).join("\n") + (newEntries.length > 0 ? "\n" : "");
+      fs.writeFileSync(timelineFile, content, "utf8");
+    } else {
+      fs.appendFileSync(timelineFile, newEntries.map((e) => JSON.stringify(e)).join("\n") + "\n", "utf8");
+    }
+
+    const prevCount = force ? 0 : (watermark.entryCount || 0);
+    const lastEntry = newEntries[newEntries.length - 1];
+    const newWatermark = {
+      busLastSeq: busResult.maxSeq,
+      lastTs: lastEntry ? lastEntry.ts : watermark.lastTs,
+      entryCount: prevCount + newEntries.length,
+      builtAt: new Date().toISOString(),
+    };
+    writeWatermark(projectRoot, newWatermark);
+    return { count: newWatermark.entryCount, newCount: newEntries.length, file: timelineFile };
+  } catch (err) {
+    debugLog("buildTimeline failed:", err.message);
+    throw err;
+  } finally {
+    releaseWatermarkLock(lock);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Read / format / render
+// ---------------------------------------------------------------------------
+
+function readTimeline(projectRoot, limit = 50) {
+  return readTailJSONL(getTimelineFile(projectRoot), limit);
+}
+
+function formatEntry(entry) {
+  if (entry.source === "bus") {
+    const label = entry.fromId && entry.fromId !== entry.from
+      ? `${entry.fromId}(${entry.from})` : entry.from;
+    return `[ufoo]<from:${label}> ${entry.message}`;
+  }
+  // manual: focus on who received it, not who sent (always user)
+  const toLabel = entry.toId && entry.toId !== entry.to
+    ? `${entry.toId}(${entry.to})` : entry.to;
+  return `[manual]<to:${toLabel}> ${entry.message}`;
+}
+
+function renderTimelineForPrompt(projectRoot, limit = 30) {
+  const entries = readTimeline(projectRoot, limit);
+  if (entries.length === 0) return "";
+
+  const lines = entries.map((entry) => {
+    const time = entry.ts ? entry.ts.slice(0, 16).replace("T", " ") : "?";
+    const prefix = entry.source === "bus"
+      ? `[ufoo]<from:${entry.from}>`
+      : `[manual]<to:${entry.to}>`;
+    const msg = entry.message.length > 200 ? entry.message.slice(0, 200) + "..." : entry.message;
+    return `${time} ${prefix} ${msg}`;
+  });
+
+  return [
+    "## Team Activity (recent agent inputs)",
+    "",
+    "This shows recent prompts sent to agents. Use it to understand what each agent is working on.",
+    "",
+    ...lines,
+  ].join("\n");
+}
+
+function showTimeline(projectRoot, limit = 50) {
+  const entries = readTimeline(projectRoot, limit);
+  if (entries.length === 0) {
+    console.log("No timeline entries found. Run `ufoo history build` first.");
+    return;
+  }
+  console.log(`=== Input Timeline (${entries.length} entries) ===\n`);
+  for (const entry of entries) {
+    const time = entry.ts ? entry.ts.slice(0, 19).replace("T", " ") : "?";
+    console.log(`[${time}] ${formatEntry(entry)}`);
+  }
+}
+
+module.exports = {
+  getHistoryDir,
+  getTimelineFile,
+  getWatermarkFile,
+  buildTimeline,
+  appendBusEntry,
+  readTimeline,
+  readWatermark,
+  formatEntry,
+  renderTimelineForPrompt,
+  showTimeline,
+  getClaudeProjectDir,
+  collectBusMessages,
+  collectClaudeManualInputs,
+  collectCodexManualInputs,
+};

package/src/{globalMode.js → projects/identity.js}

@@ -1,6 +1,6 @@
 const os = require("os");
 const path = require("path");
-const { canonicalProjectRoot, trimTrailingSlashes } = require("./projects/projectId");
+const { canonicalProjectRoot, trimTrailingSlashes } = require("./projectId");
 
 function normalizeProjectRoot(projectRoot) {
   const input = String(projectRoot || "").trim();

package/src/projects/index.js

@@ -0,0 +1,11 @@
+// Projects module: unified identity + registry + runtimes interface
+module.exports = {
+  // Identity functions (path canonicalization, global mode detection)
+  ...require("./identity"),
+  // Project ID generation
+  ...require("./projectId"),
+  // Project registry (CRUD runtime state)
+  ...require("./registry"),
+  // Project runtimes utilities (filtering, sorting, formatting)
+  ...require("./runtimes"),
+};

package/src/ufoo/paths.js

@@ -18,6 +18,7 @@ function getUfooPaths(projectRoot) {
 
   const runDir = path.join(ufooDir, "run");
   const groupsDir = path.join(ufooDir, "groups");
+  const historyDir = path.join(ufooDir, "history");
   const ufooDaemonPid = path.join(runDir, "ufoo-daemon.pid");
   const ufooDaemonLog = path.join(runDir, "ufoo-daemon.log");
   const ufooSock = path.join(runDir, "ufoo.sock");
@@ -37,6 +38,7 @@ function getUfooPaths(projectRoot) {
     busDaemonCountsDir,
     runDir,
     groupsDir,
+    historyDir,
     ufooDaemonPid,
     ufooDaemonLog,
     ufooSock,