ocuclaw 1.3.0 → 1.3.2

package/dist/runtime/session-service.js

@@ -1,12 +1,33 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { stripAllTaggedSpans } from "../domain/tagged-span-strip.js";
+import { createDisplayToggleTracker } from "./display-toggle-states.js";
+import { decideTitleWrite, isUserOrigin } from "./session-title-record.js";
+import { createDistillerBudget } from "./session-title-distiller-budget.js";
 
 const SESSION_FIRST_USER_CACHE_FILE = "session-first-user-cache.json";
 const SESSION_TITLE_CACHE_FILE = "session-title-cache.json";
 const SESSION_PIN_CACHE_FILE = "ocuclaw-session-pins.json";
 const PIN_CAP_PER_KIND = 20;
 
+/**
+ * Greeting-eliciting content appended to /new and /reset so OpenClaw runs an
+ * agent turn (the new-session "welcome"). OpenClaw 2026.6.x ("make bare reset
+ * commands fast", gateway commit 2c6a3f6b04) made a BARE /new or /reset return
+ * a synchronous ack and run NO agent turn — so a bare reset no longer produces
+ * a welcome and leaves the glasses stuck on the "starting new session"
+ * placeholder. Sending "/new <prompt>" / "/reset <prompt>" routes through the
+ * gateway's normal agent path (content = the prompt) and elicits the welcome.
+ * The wording matches the prompt OpenClaw used to inject itself, so the
+ * existing synthetic-session-starter filters (conversation-state display hide +
+ * isSyntheticSessionStarter title/preview filter) keep it hidden from the
+ * transcript and session titles. NOTE: newSession() does NOT call
+ * conversationState.addMessage("user", ...), so this content never renders as a
+ * user bubble on the glasses.
+ */
+export const NEW_SESSION_GREETING_PROMPT =
+  "A new session was started via /new or /reset. Execute your Session Startup sequence now - read the required files before responding to the user. If BOOTSTRAP.md exists in the provided Project Context, read it and follow its instructions first. Then greet the user in your configured persona, if one is provided. Be yourself - use your defined voice, mannerisms, and mood. Keep it to 1-3 sentences and ask what they want to do. If the runtime model differs from default_model in the system prompt, mention the default model. Do not mention internal steps, files, tools, or reasoning.";
+
 
 function normalizeLogger(logger) {
   if (!logger || typeof logger !== "object") {
@@ -150,6 +171,14 @@ export function createSessionService(opts = {}) {
   const sessionTitleByKey = loadSessionTitleCache();
   /** @type {Map<string, boolean>} Per-session Neural Session Names toggle state. */
   const neuralSessionNamesEnabledByKey = new Map();
+  /** Per-session display-feature (emoji/pace) toggle states: frozen start + latest.
+   * The frozen start-state persists to stateDir so a relay restart can't lose it
+   * (the Channel-1 snapshot persists too — see stable-prompt-snapshot). */
+  const displayToggleTracker = createDisplayToggleTracker({ stateDir: opts.stateDir });
+  /** Per-session SKIP-exempt budget for the background title distiller. Owned
+   * here (alongside the title record + toggle tracker) so a logical session
+   * reset clears all per-session distiller state in one place. */
+  const distillerBudget = createDistillerBudget({});
 
   /** Path for session pin metadata cache file. */
   const sessionPinCachePath = resolveSessionPinCachePath(opts.stateDir);
@@ -762,10 +791,17 @@ export function createSessionService(opts = {}) {
   function resolveRowTitle(sessionKey, row) {
     const cached = getSessionTitle(sessionKey);
     if (cached !== null) return cached;
-    // row.displayName: upstream session-row label per
-    // openclaw/docs/reference/session-management-compaction.md §169.
-    if (row && typeof row.displayName === "string") {
-      const trimmed = row.displayName.trim();
+    // Upstream session-row label: `label` on 2026.6.x rows; older hosts
+    // (≤5.27-era docs, session-management-compaction.md §169) used
+    // `displayName` — accept both.
+    const rawLabel =
+      row && typeof row.label === "string"
+        ? row.label
+        : row && typeof row.displayName === "string"
+          ? row.displayName
+          : "";
+    {
+      const trimmed = rawLabel.trim();
       if (trimmed) return trimmed;
     }
     return null;
@@ -959,6 +995,7 @@ export function createSessionService(opts = {}) {
         sessionPinByKey.delete(key);
         sessionTitleByKey.delete(key);
         firstSentUserMessageBySession.delete(key);
+        distillerBudget.clear(key);
         deleted.push(key);
       } catch (err) {
         failed.push({ key, reason: err?.message ?? "unknown" });
@@ -1266,6 +1303,11 @@ export function createSessionService(opts = {}) {
     return entry ? entry.title : null;
   }
 
+  function getSessionTitleRecord(sessionKey) {
+    const entry = sessionTitleByKey.get(sessionKey);
+    return entry ? { ...entry } : null;
+  }
+
   function setSessionTitle(sessionKey, title, opts) {
     if (typeof sessionKey !== "string" || !sessionKey.trim()) {
       return { ok: false, code: "invalid_session_key" };
@@ -1274,19 +1316,26 @@ export function createSessionService(opts = {}) {
       return { ok: false, code: "invalid_title" };
     }
     const trimmed = title.trim();
-    const setByUser = !!(opts && opts.userSet === true);
+    // Back-compat: callers passing { userSet:true } map to the user_tool origin.
+    const origin =
+      opts && typeof opts.origin === "string" && opts.origin
+        ? opts.origin
+        : opts && opts.userSet === true
+          ? "user_tool"
+          : "topic_distiller";
     const previous = sessionTitleByKey.get(sessionKey);
-
-    if (!setByUser && previous && previous.userSet === true) {
-      return { ok: false, code: "session_user_locked" };
+    const decision = decideTitleWrite(previous, origin);
+    if (!decision.allowed) {
+      return { ok: false, code: decision.code };
     }
-
     const replaced = !!previous;
-    const nextUserSet = setByUser || (previous && previous.userSet === true);
+    const nextUserSet = decision.nextUserSet;
+    const setByUser = isUserOrigin(origin);
     sessionTitleByKey.set(sessionKey, {
       title: trimmed,
       setAtMs: Date.now(),
       userSet: !!nextUserSet,
+      origin,
     });
     pruneSessionTitleEntries(sessionTitleByKey);
     persistSessionTitleCache();
@@ -1296,15 +1345,26 @@ export function createSessionService(opts = {}) {
       setByUser ? "session_title_set_by_user" : "session_title_set",
       "info",
       { sessionKey },
-      () => ({ sessionKey, title: trimmed, replaced, userSet: !!nextUserSet }),
+      () => ({ sessionKey, title: trimmed, replaced, userSet: !!nextUserSet, origin }),
     );
     // Fire-and-forget upstream mirror.
+    if (!isUpstreamConnected()) {
+      emitDebug(
+        "relay.session",
+        "session_title_upstream_mirror_skipped",
+        "debug",
+        { sessionKey },
+        () => ({ reason: "upstream_disconnected", origin }),
+      );
+    }
     if (isUpstreamConnected()) {
       resolveSessionCanonicalKey(sessionKey)
         .then((canonicalKey) =>
+          // 2026.6.x strict schema: the session title field is `label`
+          // (5.27-era `displayName` is rejected as an unexpected property).
           gatewayBridge.request("sessions.patch", {
             key: canonicalKey,
-            displayName: trimmed,
+            label: trimmed,
           }),
         )
         .catch((err) => {
@@ -1346,6 +1406,78 @@ export function createSessionService(opts = {}) {
     return cached === undefined ? true : cached;
   }
 
+  function recordDisplayToggleStates(sessionKey, states) {
+    if (typeof sessionKey !== "string" || !sessionKey.trim()) return;
+    displayToggleTracker.record(sessionKey, states);
+  }
+  function getDisplayStartStates(sessionKey) {
+    return displayToggleTracker.getStart(sessionKey);
+  }
+  function getDisplayCurrentStates(sessionKey) {
+    return displayToggleTracker.getCurrent(sessionKey);
+  }
+  function clearDisplayToggleStates(sessionKey) {
+    displayToggleTracker.clear(sessionKey);
+  }
+
+  function getDistillerBudget() {
+    return distillerBudget;
+  }
+  function clearDistillerBudget(sessionKey) {
+    if (typeof sessionKey === "string" && sessionKey.trim()) {
+      distillerBudget.clear(sessionKey);
+    }
+  }
+  // Drop the stored title record for a session AND clear the upstream display
+  // name. setSessionTitle mirrors the title to the upstream session displayName,
+  // and session-list rendering falls back to that displayName when the local
+  // record is gone — so a local-only delete would let the old title reappear on
+  // the next sessions refresh. deleteSessions removes it for genuine deletes;
+  // this is for a reused-key logical reset (/new, /reset).
+  function clearSessionTitle(sessionKey) {
+    if (typeof sessionKey !== "string" || !sessionKey.trim()) return;
+    const hadTitle = sessionTitleByKey.delete(sessionKey);
+    if (!hadTitle) return;
+    persistSessionTitleCache();
+    invalidateSessionsCache();
+    if (isUpstreamConnected()) {
+      resolveSessionCanonicalKey(sessionKey)
+        .then((canonicalKey) =>
+          gatewayBridge.request("sessions.patch", { key: canonicalKey, label: null }),
+        )
+        .catch((err) => {
+          emitDebug(
+            "relay.session",
+            "session_title_upstream_clear_failed",
+            "debug",
+            { sessionKey },
+            () => ({ message: err && err.message ? err.message : String(err) }),
+          );
+        });
+    }
+  }
+
+  // Clear ALL per-session state keyed to a conversation that must not bleed into
+  // a fresh conversation reusing the same session key (/new, /reset). Centralized
+  // so reset paths can't miss a piece (title + upstream name, toggle states,
+  // distiller budget, the first-user-message marker the distiller gate reads, and
+  // the per-session feature toggle).
+  function clearLogicalSessionState(sessionKey) {
+    if (typeof sessionKey !== "string" || !sessionKey.trim()) return;
+    clearSessionTitle(sessionKey);
+    displayToggleTracker.clear(sessionKey);
+    distillerBudget.clear(sessionKey);
+    // Clear BOTH the first-user marker AND the derived preview cache, and persist
+    // the deletion — recordFirstSentUserMessage writes the marker to disk, so a
+    // local-only delete would let a relay/plugin restart reload a stale
+    // "user already spoke" marker for the reused key (the distiller gate reads
+    // this, and the session-list preview reads the derived cache).
+    const hadMarker = firstSentUserMessageBySession.delete(sessionKey);
+    firstUserMessageCache.delete(sessionKey);
+    if (hadMarker) persistFirstSentUserMessageCache();
+    neuralSessionNamesEnabledByKey.delete(sessionKey);
+  }
+
   function isSyntheticSessionStarter(text) {
     if (!text) return false;
     if (
@@ -1575,9 +1707,11 @@ export function createSessionService(opts = {}) {
       onStatusChanged();
     }
     if (sendResetCommand && isUpstreamConnected()) {
-      gatewayBridge.sendMessage("/new", sessionKey).catch((err) => {
-        logger.error(`[relay] Failed to send /new for new session: ${err.message}`);
-      });
+      gatewayBridge
+        .sendMessage(`/new ${NEW_SESSION_GREETING_PROMPT}`, sessionKey)
+        .catch((err) => {
+          logger.error(`[relay] Failed to send /new for new session: ${err.message}`);
+        });
     }
     return { sessionKey, pages };
   }
@@ -1625,11 +1759,21 @@ export function createSessionService(opts = {}) {
     clearPendingInitialConfig,
     getSessions,
     getSessionTitle,
+    getSessionTitleRecord,
     getSessionsByExactKeys,
     hasRecordedFirstUserMessage,
     isNeuralSessionNamesEnabled,
+    isEvenAiSessionKey,
     isSessionUserLocked,
     recordNeuralSessionNamesEnabled,
+    recordDisplayToggleStates,
+    getDisplayStartStates,
+    getDisplayCurrentStates,
+    clearDisplayToggleStates,
+    getDistillerBudget,
+    clearDistillerBudget,
+    clearSessionTitle,
+    clearLogicalSessionState,
     setSessionTitle,
     switchToSession,
     newSession,

package/dist/runtime/session-title-distiller-budget.js

@@ -0,0 +1,36 @@
+/**
+ * Per-session distiller budget. SKIPs are free; only consecutive errors and a
+ * total untitled-turn ceiling bound attempts; an applied title ends attempts.
+ */
+export function createDistillerBudget(opts = {}) {
+  const maxErr = Number.isFinite(opts.maxConsecutiveErrors) ? opts.maxConsecutiveErrors : 3;
+  const ceiling = Number.isFinite(opts.untitledTurnCeiling) ? opts.untitledTurnCeiling : 25;
+  /** @type {Map<string,{consecErr:number, turns:number, done:boolean}>} */
+  const byKey = new Map();
+
+  function get(k) {
+    let s = byKey.get(k);
+    if (!s) { s = { consecErr: 0, turns: 0, done: false }; byKey.set(k, s); }
+    return s;
+  }
+
+  return {
+    recordTurn(sessionKey) { get(sessionKey).turns += 1; },
+    canRun(sessionKey) {
+      const s = get(sessionKey);
+      if (s.done) return false;
+      if (s.consecErr >= maxErr) return false;
+      if (s.turns >= ceiling) return false;
+      return true;
+    },
+    recordOutcome(sessionKey, outcome) {
+      const s = get(sessionKey);
+      if (outcome === "error") { s.consecErr += 1; return; }
+      s.consecErr = 0;
+      if (outcome === "applied") s.done = true;
+    },
+    clear(sessionKey) { byKey.delete(sessionKey); },
+  };
+}
+
+export default createDistillerBudget;

package/dist/runtime/session-title-distiller-helpers.js

@@ -0,0 +1,130 @@
+export const DISTILLER_SESSION_PREFIX = "ocuclaw:title-distiller:";
+export const TITLE_MAX = 55;
+
+export function isDistillerSessionKey(sessionKey) {
+  return typeof sessionKey === "string" && sessionKey.startsWith(DISTILLER_SESSION_PREFIX);
+}
+
+// OpenClaw hooks (agent_end et al.) deliver the CANONICAL session key —
+// `agent:<agentId>:<sessionKey>` on 2026.6.x — while relay-side state
+// (first-user marker, title record, user lock) is keyed by the bare relay
+// key the app sends with. Strip exactly one canonical prefix so gate
+// lookups and the distiller recursion guard see the relay key.
+export function stripAgentSessionPrefix(sessionKey) {
+  if (typeof sessionKey !== "string") return sessionKey;
+  const m = /^agent:[^:]+:(.+)$/.exec(sessionKey);
+  return m ? m[1] : sessionKey;
+}
+
+export function sanitizeTitle(raw) {
+  if (typeof raw !== "string") return null;
+  let s = raw.split("\n")[0].trim();
+  if (!s) return null;
+  // Strip surrounding quotes (straight or curly) and trailing sentence
+  // punctuation, repeatedly, so a combination like '"Trip Planning".' fully
+  // reduces (a single pass leaves the quote shielded behind the period).
+  let prev;
+  do {
+    prev = s;
+    s = s
+      .replace(/^["'“”‘’]+/, "")
+      .replace(/["'“”‘’]+$/, "")
+      .replace(/[.!?,;:]+$/, "")
+      .trim();
+  } while (s !== prev && s.length > 0);
+  if (!s) return null;
+  if (s.toUpperCase() === "SKIP") return null;
+  if (s.length > TITLE_MAX) s = s.slice(0, TITLE_MAX).trim();
+  return s || null;
+}
+
+export function internalTranscriptFilename(runId) {
+  const safe = String(runId == null ? "" : runId)
+    .replace(/[^a-zA-Z0-9._-]/g, "_")
+    .slice(0, 120) || "run";
+  return `${safe}.jsonl`;
+}
+
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content
+    .filter((b) => b && b.type === "text" && typeof b.text === "string")
+    .map((b) => b.text)
+    .join("");
+}
+
+/**
+ * Pull the title text out of a subagent `getSessionMessages` result: the last
+ * assistant message's text. Defensive about message shape (string or text-block
+ * array content) and about non-assistant trailing entries.
+ */
+export function extractAssistantTitleFromMessages(messages) {
+  if (!Array.isArray(messages)) return "";
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const m = messages[i];
+    if (!m || typeof m !== "object") continue;
+    if (m.role !== "assistant") continue;
+    const text = extractText(m.content);
+    if (text && text.trim()) return text;
+  }
+  return "";
+}
+
+export function buildExcerpt(messages, opts = {}) {
+  const maxMessages = Number.isFinite(opts.maxMessages) ? opts.maxMessages : 6;
+  const per = Number.isFinite(opts.perMessageChars) ? opts.perMessageChars : 280;
+  const recent = (Array.isArray(messages) ? messages : []).slice(-maxMessages);
+  return recent
+    .map((m) => {
+      const role = m && m.role === "assistant" ? "assistant" : "user";
+      let text = extractText(m && m.content).replace(/\s+/g, " ").trim();
+      if (text.length > per) text = text.slice(0, per);
+      return `${role}: ${text}`;
+    })
+    .join("\n");
+}
+
+/**
+ * Split a "provider/model" ref (the sessionTitleModel config format) into the
+ * separate provider/model fields the gateway agent RPC expects. Splits on the
+ * FIRST "/"; a bare id (or one with an empty half) stays a model-only override.
+ * Mirrors the Even-AI model hook's parseModelRef.
+ * @returns {{provider?: string, model: string} | null}
+ */
+export function splitModelRef(ref) {
+  if (typeof ref !== "string") return null;
+  const normalized = ref.trim();
+  if (!normalized) return null;
+  const slash = normalized.indexOf("/");
+  if (slash <= 0 || slash >= normalized.length - 1) {
+    return { model: normalized };
+  }
+  const provider = normalized.slice(0, slash).trim();
+  const model = normalized.slice(slash + 1).trim();
+  if (!provider || !model) return { model: normalized };
+  return { provider, model };
+}
+
+export function buildDistillerAgentParams(opts) {
+  const params = {
+    message: opts.message,
+    sessionKey: opts.sessionKey,
+    idempotencyKey: opts.idempotencyKey,
+    modelRun: true,
+    promptMode: "none",
+    sessionEffects: "internal",
+    suppressPromptPersistence: true,
+    disableMessageTool: true,
+    deliver: false,
+    lane: "background",
+  };
+  // The gateway agent RPC takes provider + model as SEPARATE fields; the config
+  // value is "provider/model", so split it rather than sending the slash string.
+  const ref = splitModelRef(opts.model);
+  if (ref) {
+    if (ref.provider) params.provider = ref.provider;
+    params.model = ref.model;
+  }
+  return params;
+}