chainlesschain 0.165.5 → 0.165.8

package/src/lib/session-projection.js

@@ -84,6 +84,29 @@ function asText(value) {
   return typeof value === "string" && value.trim() ? value.trim() : null;
 }
 
+function boundedText(value, maxChars = 240) {
+  let text = null;
+  if (typeof value === "string") text = value;
+  else if (value && typeof value === "object") {
+    text =
+      value.summary ||
+      value.title ||
+      value.question ||
+      value.text ||
+      value.answer ||
+      null;
+  }
+  if (typeof text !== "string") return null;
+  const normalized = text
+    .replace(/[\u0000-\u001f\u007f]+/gu, " ")
+    .replace(/\s+/gu, " ")
+    .trim();
+  if (!normalized) return null;
+  return normalized.length <= maxChars
+    ? normalized
+    : `${normalized.slice(0, Math.max(0, maxChars - 1))}…`;
+}
+
 function asCount(value) {
   const number = Number(value);
   return Number.isFinite(number) && number > 0 ? Math.floor(number) : 0;
@@ -615,6 +638,209 @@ function approvalSummary(source, state) {
   };
 }
 
+function messagingSummary(sessionIds, fabric) {
+  const linked = new Set(
+    (Array.isArray(sessionIds) ? sessionIds : [sessionIds]).filter(Boolean),
+  );
+  const endpoints = Array.isArray(fabric?.endpoints)
+    ? fabric.endpoints
+        .filter((endpoint) => linked.has(endpoint?.sessionId))
+        .map((endpoint) => ({
+          name: asText(endpoint?.name),
+          address: asText(endpoint?.address),
+          policy: ["accept", "hold", "refuse"].includes(endpoint?.policy)
+            ? endpoint.policy
+            : "refuse",
+          online: endpoint?.online === true,
+          idle: endpoint?.idle === true,
+          unread: asCount(endpoint?.unread),
+          held: asCount(endpoint?.held),
+        }))
+        .filter((endpoint) => endpoint.name && endpoint.address)
+        .sort((left, right) => left.name.localeCompare(right.name))
+    : [];
+  return {
+    authority: "cli",
+    registered: endpoints.length > 0,
+    revision: Number.isSafeInteger(fabric?.revision) ? fabric.revision : 0,
+    unread: endpoints.reduce((total, endpoint) => total + endpoint.unread, 0),
+    held: endpoints.reduce((total, endpoint) => total + endpoint.held, 0),
+    endpoints,
+  };
+}
+
+function pendingInteractionCount(source) {
+  if (Array.isArray(source?.pendingInteractions)) {
+    return Math.min(1_000, source.pendingInteractions.length);
+  }
+  return Math.min(1_000, asCount(source?.pendingInteractions));
+}
+
+function liveToolSummary(source) {
+  const candidate =
+    source?.liveTool || source?.currentTool || source?.recent?.call || null;
+  const name = boundedText(candidate?.name || candidate?.tool || candidate, 96);
+  if (!name) return null;
+  return {
+    name,
+    status: boundedText(candidate?.status || source?.toolStatus, 48),
+  };
+}
+
+function focusSummary(source, state) {
+  const pendingQuestion = boundedText(source?.pendingQuestion, 240);
+  const todos = Array.isArray(source?.todos) ? source.todos : [];
+  const latestTodo = boundedText(
+    source?.latestTodo || source?.todo?.latest || todos.at(-1),
+    240,
+  );
+  const settledAnswer = boundedText(
+    source?.settledAnswer || source?.lastAnswer || source?.answerSummary,
+    240,
+  );
+  const liveTool = liveToolSummary(source);
+  return {
+    active: ["working", "needs_input", "blocked"].includes(state),
+    liveTool,
+    latestTodo,
+    pendingQuestion,
+    settledAnswer,
+  };
+}
+
+function locationSummary(source, kind) {
+  const hint = String(
+    source?.executionLocation?.kind ||
+      source?.executionLocation ||
+      source?.location?.kind ||
+      source?.location ||
+      source?.origin ||
+      "",
+  )
+    .trim()
+    .toLowerCase();
+  const locationKind =
+    source?.cloud === true || hint === "cloud"
+      ? "cloud"
+      : kind === "remote"
+        ? "remote"
+        : "local";
+  const connection = String(source?.connection || source?.connectivity || "")
+    .trim()
+    .toLowerCase();
+  const offline =
+    source?.offline === true ||
+    source?.online === false ||
+    ["offline", "disconnected", "unreachable"].includes(connection) ||
+    (kind === "remote" && source?.alive !== true);
+  const online =
+    !offline &&
+    (source?.online === true ||
+      ["online", "connected"].includes(connection) ||
+      (kind === "remote" && source?.alive === true) ||
+      locationKind === "cloud");
+  return {
+    kind: locationKind,
+    status: offline ? "offline" : online ? "online" : "local",
+  };
+}
+
+function groupingSummary(workbench, error) {
+  if (error) {
+    return {
+      authority: "cli",
+      connected: false,
+      revision: null,
+      generation: 0,
+      reason: String(error).slice(0, 240),
+      items: [],
+      assignments: [],
+    };
+  }
+  if (workbench == null) {
+    const items = [];
+    const assignments = [];
+    return {
+      authority: "cli",
+      connected: true,
+      revision: projectionRevision({
+        schema: "chainlesschain.session-workbench-state/v1",
+        generation: 0,
+        groups: [],
+        memberships: {},
+      }),
+      generation: 0,
+      items,
+      assignments,
+    };
+  }
+  if (
+    typeof workbench !== "object" ||
+    workbench.authority !== "cli" ||
+    workbench.connected !== true ||
+    typeof workbench.revision !== "string" ||
+    !Number.isSafeInteger(workbench.generation) ||
+    workbench.generation < 0 ||
+    !Array.isArray(workbench.items) ||
+    workbench.items.length > 128 ||
+    !Array.isArray(workbench.assignments) ||
+    workbench.assignments.length > 4096
+  ) {
+    return groupingSummary(null, "session group projection is malformed");
+  }
+  const ids = new Set();
+  const items = [];
+  for (const raw of workbench.items) {
+    const id = asText(raw?.id);
+    const name = boundedText(raw?.name, 80);
+    const order = Number(raw?.order);
+    if (
+      !id ||
+      !/^group-[a-zA-Z0-9_-]+$/u.test(id) ||
+      !name ||
+      !Number.isSafeInteger(order) ||
+      order < 0 ||
+      ids.has(id)
+    ) {
+      return groupingSummary(null, "session group projection is malformed");
+    }
+    ids.add(id);
+    items.push({ id, name, order });
+  }
+  items.sort(
+    (left, right) =>
+      left.order - right.order || left.name.localeCompare(right.name),
+  );
+  const assignments = [];
+  const seenSessions = new Set();
+  for (const raw of workbench.assignments) {
+    const sessionId = asText(raw?.sessionId);
+    const groupId = asText(raw?.groupId);
+    if (
+      !sessionId ||
+      sessionId.length > 512 ||
+      !groupId ||
+      !ids.has(groupId) ||
+      seenSessions.has(sessionId)
+    ) {
+      return groupingSummary(null, "session group projection is malformed");
+    }
+    seenSessions.add(sessionId);
+    assignments.push({ sessionId, groupId });
+  }
+  assignments.sort((left, right) =>
+    left.sessionId.localeCompare(right.sessionId),
+  );
+  return {
+    authority: "cli",
+    connected: true,
+    revision: workbench.revision,
+    generation: workbench.generation,
+    items,
+    assignments,
+  };
+}
+
 function lastEventFor(source, state) {
   const at =
     toIso(source?.lastEvent?.at) ||
@@ -629,7 +855,11 @@ function lastEventFor(source, state) {
   };
 }
 
-function projectOne(kind, source, { artifacts, prLinks }) {
+function projectOne(
+  kind,
+  source,
+  { artifacts, prLinks, sessionMessageFabric, groupAssignments },
+) {
   let sourceId;
   if (kind === "remote") {
     const stateFile = asText(source?.stateFile);
@@ -672,6 +902,11 @@ function projectOne(kind, source, { artifacts, prLinks }) {
     sourceId,
     linkedSessionId,
   );
+  const approval = approvalSummary(source, state);
+  const messaging = messagingSummary(linkedSessionIds, sessionMessageFabric);
+  const focus = focusSummary(source, state);
+  const groupId =
+    groupAssignments.get(canonicalSessionId(kind, sourceId)) || null;
   const projected = {
     id: canonicalSessionId(kind, sourceId),
     sourceId,
@@ -700,7 +935,19 @@ function projectOne(kind, source, { artifacts, prLinks }) {
       kind === "dynamic_workflow"
         ? { count: asCount(source?.artifacts?.count), latest: null }
         : artifactSummary(linkedSessionIds, artifacts),
-    approval: approvalSummary(source, state),
+    approval,
+    messaging,
+    groupId,
+    attention: {
+      unread: messaging.unread,
+      needsApproval: approval.pending,
+      pendingInteractions: Math.min(
+        1_000,
+        pendingInteractionCount(source) + (focus.pendingQuestion ? 1 : 0),
+      ),
+    },
+    focus,
+    location: locationSummary(source, kind),
     pr: prSummary(linkedSessionIds, prLinks),
     workflow: dynamicWorkflowSummary(source),
     lastEvent: lastEventFor(source, state),
@@ -726,10 +973,24 @@ export function buildSessionProjection({
   dynamicWorkflow = [],
   artifacts = [],
   prLinks = {},
+  sessionMessageFabric = null,
+  sessionWorkbench = null,
   sourceErrors = {},
   generatedAt = new Date().toISOString(),
 } = {}) {
-  const context = { artifacts, prLinks };
+  const groups = groupingSummary(
+    sessionWorkbench,
+    sourceErrors.sessionWorkbench,
+  );
+  const groupAssignments = new Map(
+    groups.assignments.map((entry) => [entry.sessionId, entry.groupId]),
+  );
+  const context = {
+    artifacts,
+    prLinks,
+    sessionMessageFabric,
+    groupAssignments,
+  };
   const sessions = [
     ...(Array.isArray(local) ? local : []).map((source) =>
       projectOne("local", source, context),
@@ -785,6 +1046,17 @@ export function buildSessionProjection({
       Array.isArray(dynamicWorkflow) ? dynamicWorkflow.length : 0,
       sourceErrors.dynamicWorkflow,
     ),
+    sessionMessageFabric: sourceStatus(
+      Array.isArray(sessionMessageFabric?.endpoints)
+        ? sessionMessageFabric.endpoints.length
+        : 0,
+      sourceErrors.sessionMessageFabric,
+    ),
+    sessionWorkbench: sourceStatus(
+      groups.connected ? groups.items.length : 0,
+      sourceErrors.sessionWorkbench ||
+        (groups.connected ? null : groups.reason),
+    ),
   };
   const revision = projectionRevision({
     schema: SESSION_PROJECTION_SCHEMA,
@@ -793,6 +1065,7 @@ export function buildSessionProjection({
       id: session.id,
       revision: session.revision,
     })),
+    groupRevision: groups.revision,
   });
   return {
     schema: SESSION_PROJECTION_SCHEMA,
@@ -802,6 +1075,7 @@ export function buildSessionProjection({
     generatedAt: toIso(generatedAt) || new Date().toISOString(),
     revision,
     sources,
+    groups,
     sessions,
   };
 }
@@ -919,6 +1193,15 @@ export function disconnectedSessionProjection(reasonText = "CLI unavailable") {
     revision: projectionRevision({ connected: false, reason }),
     reason,
     sources: {},
+    groups: {
+      authority: "cli",
+      connected: false,
+      revision: null,
+      generation: 0,
+      reason,
+      items: [],
+      assignments: [],
+    },
     sessions: [],
   };
 }

package/src/lib/session-runtime-retention.js

@@ -0,0 +1,155 @@
+/** Bounded live-state retention for long-running agent conversations. */
+
+import { createHash } from "node:crypto";
+
+export const SESSION_RUNTIME_RETENTION_LIMITS = Object.freeze({
+  recentResults: 32,
+  retainedResultChars: 512,
+  markerHeadChars: 128,
+  markerTailChars: 128,
+});
+
+export const SESSION_RUNTIME_RELEASE_MARKER = "…[live result released:";
+const BACKGROUND_RESULT_PREFIX = '[Background sub-agent "';
+
+function normalizedLimit(value, fallback, minimum = 0) {
+  return Number.isFinite(value)
+    ? Math.max(minimum, Math.floor(value))
+    : fallback;
+}
+
+function resultContent(message) {
+  if (!message || typeof message.content !== "string") return null;
+  if (message.role === "tool") return message.content;
+  if (
+    message.role === "user" &&
+    message.content.startsWith(BACKGROUND_RESULT_PREFIX)
+  ) {
+    return message.content;
+  }
+  return null;
+}
+
+// V8 may represent `slice()` as a view that keeps the entire source string's
+// backing store alive. Joining individual UTF-16 code units forces a small,
+// independent flat string while preserving even unpaired surrogate units.
+function detachedSlice(content, start, end) {
+  const length = Math.max(0, end - start);
+  const units = new Array(length);
+  for (let index = 0; index < length; index += 1) {
+    units[index] = content.charAt(start + index);
+  }
+  return units.join("");
+}
+
+function releaseProjection(content, options) {
+  const digest = createHash("sha256").update(content, "utf8").digest("hex");
+  const marker =
+    `${SESSION_RUNTIME_RELEASE_MARKER} ${content.length} chars; sha256:${digest}; ` +
+    "full evidence remains in the durable transcript]";
+  const maxChars = options.retainedResultChars;
+  if (marker.length >= maxChars) {
+    return { content: marker.slice(0, maxChars), digest };
+  }
+  const remaining = maxChars - marker.length - 2;
+  const headChars = Math.min(
+    options.markerHeadChars,
+    Math.max(0, Math.floor(remaining / 2)),
+  );
+  const tailChars = Math.min(
+    options.markerTailChars,
+    Math.max(0, remaining - headChars),
+  );
+  const head = detachedSlice(content, 0, headChars);
+  const tail =
+    tailChars > 0
+      ? detachedSlice(content, content.length - tailChars, content.length)
+      : "";
+  return {
+    content: `${head}\n${marker}\n${tail}`.slice(0, maxChars),
+    digest,
+  };
+}
+
+/**
+ * Replace old live tool/subagent result bodies with a bounded head/tail,
+ * digest, and durable-transcript locator. The message and pairing structure is
+ * retained; only old result content is released. The returned array is new and
+ * the input is never mutated.
+ */
+export function releaseOldLiveSessionResults(messages, configured = {}) {
+  if (!Array.isArray(messages)) {
+    return {
+      messages,
+      stats: {
+        strategy: "session-runtime-retention",
+        released: 0,
+        savedChars: 0,
+        recentResults: 0,
+        durableReferences: [],
+      },
+    };
+  }
+  const options = {
+    recentResults: normalizedLimit(
+      configured.recentResults,
+      SESSION_RUNTIME_RETENTION_LIMITS.recentResults,
+    ),
+    retainedResultChars: normalizedLimit(
+      configured.retainedResultChars,
+      SESSION_RUNTIME_RETENTION_LIMITS.retainedResultChars,
+      256,
+    ),
+    markerHeadChars: normalizedLimit(
+      configured.markerHeadChars,
+      SESSION_RUNTIME_RETENTION_LIMITS.markerHeadChars,
+    ),
+    markerTailChars: normalizedLimit(
+      configured.markerTailChars,
+      SESSION_RUNTIME_RETENTION_LIMITS.markerTailChars,
+    ),
+  };
+  const resultIndexes = [];
+  for (let index = 0; index < messages.length; index += 1) {
+    if (resultContent(messages[index]) != null) resultIndexes.push(index);
+  }
+  const releaseCount = Math.max(
+    0,
+    resultIndexes.length - options.recentResults,
+  );
+  const releaseIndexes = new Set(resultIndexes.slice(0, releaseCount));
+  let released = 0;
+  let savedChars = 0;
+  const durableReferences = [];
+  const output = messages.map((message, index) => {
+    if (!releaseIndexes.has(index)) return message;
+    const content = resultContent(message);
+    if (content.length <= options.retainedResultChars) {
+      return message;
+    }
+    const projection = releaseProjection(content, options);
+    released += 1;
+    savedChars += content.length - projection.content.length;
+    durableReferences.push({
+      messageIndex: index,
+      digest: `sha256:${projection.digest}`,
+      originalChars: content.length,
+      retainedChars: projection.content.length,
+    });
+    return { ...message, content: projection.content };
+  });
+  return {
+    messages: output,
+    stats: {
+      strategy: "session-runtime-retention",
+      released,
+      savedChars,
+      saved: savedChars,
+      recentResults: Math.min(options.recentResults, resultIndexes.length),
+      retainedResultChars: options.retainedResultChars,
+      originalMessages: messages.length,
+      compressedMessages: output.length,
+      durableReferences,
+    },
+  };
+}

package/src/lib/session-store-guard.js

@@ -11,9 +11,11 @@
 
 import { resolve, relative, isAbsolute, join } from "node:path";
 import { getHomeDir } from "./paths.js";
+import { resolveClaudeProjectStorageDir } from "./claude-project-storage-layout.js";
 
 export function sessionStoreDir() {
-  return join(getHomeDir(), "sessions");
+  const homeDir = getHomeDir();
+  return resolveClaudeProjectStorageDir(homeDir) || join(homeDir, "sessions");
 }
 
 /**