u-foo 3.0.24 → 3.0.26

package/package.json

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

package/src/code/UcodeController.js

@@ -106,27 +106,20 @@ function createUcodeController({
  */
 function createThinkingStatusPublisher(publish, options = {}) {
   const intervalMs = Number(options.intervalMs) > 0 ? Number(options.intervalMs) : 120;
-  let tail = "";
   let timer = null;
   let lastFlush = 0;
 
-  function collapse(text) {
-    const raw = String(text || "").replace(/\s+/g, " ").trim();
-    if (!raw) return "Thinking…";
-    return raw.length > 72 ? `${raw.slice(-72)}` : raw;
-  }
-
   function flush() {
     timer = null;
     lastFlush = Date.now();
     publish("status.set", {
-      text: collapse(tail),
+      text: "Thinking…",
       busy: true,
     });
   }
 
   function onThinkingDelta(chunk) {
-    tail += String(chunk || "");
+    if (!String(chunk || "")) return;
     const elapsed = Date.now() - lastFlush;
     if (elapsed >= intervalMs) {
       flush();
@@ -143,7 +136,6 @@ function createThinkingStatusPublisher(publish, options = {}) {
       clearTimeout(timer);
       timer = null;
     }
-    tail = "";
     lastFlush = 0;
   }
 

package/src/code/agent.js

@@ -1,5 +1,6 @@
 const fs = require("fs");
 const path = require("path");
+const { randomUUID } = require("crypto");
 const { runToolCall } = require("./dispatch");
 const { runNativeAgentTask } = require("./nativeRunner");
 const { runDecomposedTask } = require("./taskDecomposer");
@@ -13,13 +14,13 @@ const {
 const { buildSkillInjections } = require("./skills");
 const {
   assembleModelContext,
-  syncMessagesToTranscript,
   applyContextSideEffects,
   ensureProjectSnapshot,
   recordToolCallInSession,
   commitAfterSegmentEnd,
-  sanitizeModelMessages,
 } = require("./context/assembler");
+const { appendTurnMessages } = require("./conversation/sessionJournal");
+const { loadTranscript, transcriptEventsToMessages } = require("./context/transcript");
 const { buildLayeredSystemPrompt } = require("./context/promptLayers");
 const {
   createProjectPreflightContextV2,
@@ -539,6 +540,7 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
   const analysisTask = isProjectAnalysisTask(taskText);
   const workspaceRoot = String(state.workspaceRoot || process.cwd());
   ensureContextSessionState(state);
+  state.sessionId = resolveSessionId(state.sessionId);
 
   let projectSnapshot = state.projectSnapshot || null;
   if (analysisTask) {
@@ -591,6 +593,26 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
   });
   const systemContext = assembled.systemPrompt;
   state.summary = assembled.summary || state.summary;
+  const turnId = `turn_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+  const inputAppend = appendTurnMessages(
+    workspaceRoot,
+    String(state.sessionId || ""),
+    turnId,
+    [{ role: "user", content: taskText }],
+    { scope: "input" },
+  );
+  if (!inputAppend.ok) {
+    return {
+      ok: false,
+      summary: "",
+      artifacts: [],
+      logs: logs.slice(),
+      error: `failed to persist conversation input: ${inputAppend.error}`,
+      metrics: {},
+      streamed: false,
+      streamLastChar: "",
+    };
+  }
 
   const onStream = onDelta
     ? (delta) => {
@@ -625,13 +647,9 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
     }
     return state.contextMeter;
   };
-  let lastTranscriptBaseline = 0;
   const invokeNative = (sessionIdValue = "", timeoutOverrideMs = timeoutMs) => {
     toolEventsThisAttempt = 0;
     const historyMessages = assembled.messages;
-    // Sanitized length matches what nativeRunner clones before appending this
-    // turn's user/tool/assistant messages — used as the transcript sync baseline.
-    lastTranscriptBaseline = sanitizeModelMessages(historyMessages).length;
     return runNativeAgentImpl({
       workspaceRoot,
       provider,
@@ -706,12 +724,13 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
           ok: true,
           output: decomposedResult.summary,
           sessionId: state.sessionId,
-          messages: state.nlMessages,
+          turnItems: decomposedResult.turnItems,
         };
       } else {
         cliRes = {
           ok: false,
           error: decomposedResult.error,
+          turnItems: decomposedResult.turnItems,
         };
       }
     } else {
@@ -729,6 +748,34 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
       }
     }
 
+    const outputItems = cliRes && Array.isArray(cliRes.turnItems) ? cliRes.turnItems : [];
+    if (outputItems.length > 0) {
+      const outputAppend = appendTurnMessages(
+        workspaceRoot,
+        String(state.sessionId || ""),
+        turnId,
+        outputItems,
+        { scope: "output" },
+      );
+      if (!outputAppend.ok) {
+        return {
+          ok: false,
+          summary: "",
+          artifacts: [],
+          logs: logs.slice(),
+          error: `failed to persist conversation output: ${outputAppend.error}`,
+          metrics: {},
+          streamed: Boolean(streamed || (cliRes && cliRes.streamed)),
+          streamLastChar,
+        };
+      }
+    }
+    const transcript = loadTranscript(workspaceRoot, String(state.sessionId || ""));
+    state.transcriptEvents = transcript.events;
+    state.nlMessages = stripSkillBlocksFromMessages(
+      transcriptEventsToMessages(transcript.events, { preferArtifact: true }),
+    );
+
     if (!cliRes || cliRes.ok === false) {
       const errMsg = String((cliRes && cliRes.error) || "");
       if (isCliCancelledError(errMsg) && state.executionState) {
@@ -746,9 +793,8 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
         streamLastChar,
       };
     }
-    if (cliRes && typeof cliRes.sessionId === "string" && cliRes.sessionId.trim()) {
-      state.sessionId = cliRes.sessionId.trim();
-    }
+    // The turn coordinator owns session identity. Providers/runners receive it
+    // as correlation metadata but cannot redirect durable writes mid-turn.
     if (cliRes && cliRes.executionState && typeof cliRes.executionState === "object") {
       // Preserve planMode if the runner returned a fresh empty state without it.
       const priorPlanMode = Boolean(state.executionState && state.executionState.planMode);
@@ -763,18 +809,6 @@ async function runNaturalLanguageTask(task = "", state = {}, options = {}) {
         state.executionState.planModeSource = priorSource;
       }
     }
-    if (cliRes && Array.isArray(cliRes.messages)) {
-      // Sync first so ensureTranscript does not migrate the just-assigned
-      // nlMessages and then append the same delta again.
-      syncMessagesToTranscript(state, cliRes.messages, workspaceRoot, {
-        baselineCount: lastTranscriptBaseline,
-      });
-      state.nlMessages = stripSkillBlocksFromMessages(
-        Array.isArray(state.nlMessages) && state.nlMessages.length > 0
-          ? state.nlMessages
-          : cliRes.messages,
-      );
-    }
     const normalized = String(cliRes.output || "").trim();
     const sideEffects = parseStructuredSideEffects(normalized);
     if (sideEffects) {
@@ -1028,6 +1062,9 @@ function resumeSessionState(state = {}, sessionId = "", workspaceRoot = process.
   state.contextMeter = snapshot.contextMeter && typeof snapshot.contextMeter === "object"
     ? snapshot.contextMeter
     : null;
+  // A resume is a pure projection rebuild. Never reuse events belonging to
+  // the session that happened to be active before /resume.
+  state.transcriptEvents = [];
   ensureContextSessionState(state);
   const { ensureTranscript } = require("./context/assembler");
   ensureTranscript(state, state.workspaceRoot);
@@ -1051,6 +1088,7 @@ function resumeSessionState(state = {}, sessionId = "", workspaceRoot = process.
  */
 async function resumeAfterUserInteraction(answerText = "", state = {}, options = {}) {
   ensureContextSessionState(state);
+  state.sessionId = resolveSessionId(state.sessionId);
   const { resolveUserInteraction } = require("./context/userInteraction");
   const { appendAnswerToolResult } = require("./nativeRunner");
   const resolved = resolveUserInteraction(state.executionState, answerText);
@@ -1071,6 +1109,7 @@ async function resumeAfterUserInteraction(answerText = "", state = {}, options =
   };
 
   let messages = Array.isArray(state.nlMessages) ? state.nlMessages.slice() : [];
+  const inputStart = messages.length;
   if (resolved.continueMode === "tool_result" && resolved.resume && resolved.resume.call) {
     const appended = appendAnswerToolResult(messages, resolved.resume, resolved.answer);
     if (!appended.ok) {
@@ -1083,9 +1122,28 @@ async function resumeAfterUserInteraction(answerText = "", state = {}, options =
       content: JSON.stringify(resolved.answer),
     });
   }
-  state.nlMessages = messages;
-
   const workspaceRoot = state.workspaceRoot || process.cwd();
+  const turnId = `turn_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+  const interactionItems = messages.slice(inputStart);
+  const interactionAppend = appendTurnMessages(
+    workspaceRoot,
+    String(state.sessionId || ""),
+    turnId,
+    interactionItems,
+    { scope: "interaction" },
+  );
+  if (!interactionAppend.ok) {
+    return {
+      ok: false,
+      error: `failed to persist interaction answer: ${interactionAppend.error}`,
+    };
+  }
+  let transcript = loadTranscript(workspaceRoot, String(state.sessionId || ""));
+  state.transcriptEvents = transcript.events;
+  state.nlMessages = stripSkillBlocksFromMessages(
+    transcriptEventsToMessages(transcript.events, { preferArtifact: true }),
+  );
+
   const assembled = assembleModelContext(state, {
     workspaceRoot,
     provider: state.provider,
@@ -1131,9 +1189,30 @@ async function resumeAfterUserInteraction(answerText = "", state = {}, options =
   if (cliRes && cliRes.executionState) {
     state.executionState = cliRes.executionState;
   }
-  if (cliRes && Array.isArray(cliRes.messages)) {
-    state.nlMessages = stripSkillBlocksFromMessages(cliRes.messages);
+  if (cliRes && Array.isArray(cliRes.turnItems) && cliRes.turnItems.length > 0) {
+    const outputAppend = appendTurnMessages(
+      workspaceRoot,
+      String(state.sessionId || ""),
+      turnId,
+      cliRes.turnItems,
+      { scope: "output" },
+    );
+    if (!outputAppend.ok) {
+      return {
+        ok: false,
+        error: `failed to persist interaction output: ${outputAppend.error}`,
+        logs,
+        waitingUserInteraction: false,
+        streamed: Boolean(cliRes.streamed),
+        streamLastChar,
+      };
+    }
   }
+  transcript = loadTranscript(workspaceRoot, String(state.sessionId || ""));
+  state.transcriptEvents = transcript.events;
+  state.nlMessages = stripSkillBlocksFromMessages(
+    transcriptEventsToMessages(transcript.events, { preferArtifact: true }),
+  );
   if (cliRes && cliRes.contextMeter) {
     state.contextMeter = cliRes.contextMeter;
   }

package/src/code/context/assembler.js

@@ -5,7 +5,6 @@ const {
   transcriptEventsToMessages,
   migrateNlMessagesToTranscript,
 } = require("./transcript");
-const { appendTranscriptMessagesForStorage } = require("./transcriptSync");
 const { reduceToolResult } = require("./reducers");
 const { saveArtifact } = require("./artifacts");
 const { buildLayeredSystemPrompt } = require("./promptLayers");
@@ -551,104 +550,6 @@ function recordToolCallInSession(session = {}, persisted = {}, workspaceRoot = p
   }
 }
 
-function syncMessagesToTranscript(session = {}, messages = [], workspaceRoot = process.cwd(), options = {}) {
-  const sessionId = String(session.sessionId || "").trim();
-  if (!sessionId) return [];
-  const prior = ensureTranscript(session, workspaceRoot);
-  const full = Array.isArray(messages) ? messages : [];
-  if (full.length === 0) return prior;
-
-  // `messages` is often a WINDOWED model view (plus this turn's delta), not the
-  // full transcript. Comparing lengths to prior transcript events dropped every
-  // new user turn once the transcript grew past the window — resume then lost
-  // green › user rows. Prefer an explicit baseline, else suffix/prefix match.
-  let baseline = Number.isFinite(options.baselineCount)
-    ? Math.max(0, Math.floor(options.baselineCount))
-    : null;
-  if (baseline == null) {
-    const existingMessages = transcriptEventsToMessages(prior, {
-      preferArtifact: true,
-    });
-    baseline = matchTranscriptBaseline(existingMessages, full);
-  }
-  baseline = Math.max(0, Math.min(full.length, baseline));
-
-  if (full.length <= baseline) {
-    session.nlMessages = transcriptEventsToMessages(session.transcriptEvents, {
-      preferArtifact: true,
-    });
-    return session.transcriptEvents || prior;
-  }
-
-  const delta = full.slice(baseline);
-  const extra = {
-    segmentId: session.executionState && session.executionState.currentSegmentId
-      ? session.executionState.currentSegmentId
-      : "",
-  };
-  appendTranscriptMessagesForStorage(workspaceRoot, sessionId, delta, extra);
-  session.transcriptEvents = loadTranscript(workspaceRoot, sessionId).events;
-  session.nlMessages = transcriptEventsToMessages(session.transcriptEvents, {
-    preferArtifact: true,
-  });
-  session.summary = buildRollingSummary(session.transcriptEvents, session.summary, session);
-  return session.transcriptEvents;
-}
-
-/**
- * Fingerprint a chat message for transcript alignment. Tool payloads are
- * compared by call id (content is often artifact-compressed on disk).
- */
-function messageSyncFingerprint(message = {}) {
-  if (!message || typeof message !== "object") return "";
-  const role = String(message.role || "").trim().toLowerCase();
-  if (role === "tool") {
-    return `tool|${String(message.tool_call_id || "").trim()}`;
-  }
-  if (role === "assistant" && Array.isArray(message.tool_calls) && message.tool_calls.length > 0) {
-    const ids = message.tool_calls
-      .map((call) => String((call && call.id) || "").trim())
-      .filter(Boolean)
-      .join(",");
-    return `assistant_tools|${ids}`;
-  }
-  let content = "";
-  if (typeof message.content === "string") content = message.content;
-  else if (message.content != null) {
-    try {
-      content = JSON.stringify(message.content);
-    } catch {
-      content = String(message.content);
-    }
-  }
-  const compact = content.replace(/\s+/g, " ").trim();
-  return `${role}|${compact.length}|${compact.slice(0, 240)}`;
-}
-
-/**
- * How much of `next` is already covered by the end of `existing`.
- * Returns the length of the matched prefix of `next` (baseline for slicing).
- */
-function matchTranscriptBaseline(existing = [], next = []) {
-  const prior = Array.isArray(existing) ? existing : [];
-  const incoming = Array.isArray(next) ? next : [];
-  if (incoming.length === 0) return 0;
-  const priorFingerprints = prior.map(messageSyncFingerprint);
-  const nextFingerprints = incoming.map(messageSyncFingerprint);
-  const max = Math.min(priorFingerprints.length, nextFingerprints.length);
-  for (let k = max; k >= 0; k -= 1) {
-    let matched = true;
-    for (let i = 0; i < k; i += 1) {
-      if (priorFingerprints[priorFingerprints.length - k + i] !== nextFingerprints[i]) {
-        matched = false;
-        break;
-      }
-    }
-    if (matched) return k;
-  }
-  return 0;
-}
-
 function applyContextSideEffects(session = {}, sideEffects = {}, workspaceRoot = process.cwd()) {
   const effects = sideEffects && typeof sideEffects === "object" ? sideEffects : {};
   if (effects.stateCommit) {
@@ -710,10 +611,7 @@ module.exports = {
   assembleModelContext,
   persistToolResultToContext,
   recordToolCallInSession,
-  syncMessagesToTranscript,
   applyContextSideEffects,
   commitAfterSegmentEnd,
   ensureProjectSnapshot,
-  messageSyncFingerprint,
-  matchTranscriptBaseline,
 };

package/src/code/context/transcript.js

@@ -74,6 +74,11 @@ function readTranscriptFile(filePath = "") {
 }
 
 function loadTranscript(workspaceRoot = process.cwd(), sessionId = "") {
+  const { loadTranscriptProjection } = require("../conversation/sessionJournal");
+  const projected = loadTranscriptProjection(workspaceRoot, sessionId);
+  if (projected.source === "journal-v3" || projected.events.length > 0) {
+    return projected;
+  }
   const filePath = getTranscriptFilePath(workspaceRoot, sessionId);
   return {
     filePath,