chainlesschain 0.165.5 → 0.165.6

package/src/lib/session-projection.js

@@ -615,6 +615,37 @@ 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 lastEventFor(source, state) {
   const at =
     toIso(source?.lastEvent?.at) ||
@@ -629,7 +660,11 @@ function lastEventFor(source, state) {
   };
 }
 
-function projectOne(kind, source, { artifacts, prLinks }) {
+function projectOne(
+  kind,
+  source,
+  { artifacts, prLinks, sessionMessageFabric },
+) {
   let sourceId;
   if (kind === "remote") {
     const stateFile = asText(source?.stateFile);
@@ -701,6 +736,7 @@ function projectOne(kind, source, { artifacts, prLinks }) {
         ? { count: asCount(source?.artifacts?.count), latest: null }
         : artifactSummary(linkedSessionIds, artifacts),
     approval: approvalSummary(source, state),
+    messaging: messagingSummary(linkedSessionIds, sessionMessageFabric),
     pr: prSummary(linkedSessionIds, prLinks),
     workflow: dynamicWorkflowSummary(source),
     lastEvent: lastEventFor(source, state),
@@ -726,10 +762,11 @@ export function buildSessionProjection({
   dynamicWorkflow = [],
   artifacts = [],
   prLinks = {},
+  sessionMessageFabric = null,
   sourceErrors = {},
   generatedAt = new Date().toISOString(),
 } = {}) {
-  const context = { artifacts, prLinks };
+  const context = { artifacts, prLinks, sessionMessageFabric };
   const sessions = [
     ...(Array.isArray(local) ? local : []).map((source) =>
       projectOne("local", source, context),
@@ -785,6 +822,12 @@ export function buildSessionProjection({
       Array.isArray(dynamicWorkflow) ? dynamicWorkflow.length : 0,
       sourceErrors.dynamicWorkflow,
     ),
+    sessionMessageFabric: sourceStatus(
+      Array.isArray(sessionMessageFabric?.endpoints)
+        ? sessionMessageFabric.endpoints.length
+        : 0,
+      sourceErrors.sessionMessageFabric,
+    ),
   };
   const revision = projectionRevision({
     schema: SESSION_PROJECTION_SCHEMA,

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/settings-loader.cjs

@@ -438,6 +438,34 @@ function readBooleanSetting(key, opts = {}) {
   return value;
 }
 
+/**
+ * Read a string setting across the layered `.claude/settings.json` files.
+ * The closest layer wins and managed settings remain authoritative. Blank and
+ * non-string values are ignored so they cannot erase a valid lower layer.
+ *
+ * @param {string} key settings key or dotted path
+ * @param {object} [opts]
+ * @returns {string|undefined}
+ */
+function readStringSetting(key, opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  const parts = String(key).split(".");
+  let value;
+  const absorb = (data) => {
+    let node = data;
+    for (const part of parts) {
+      node = node && typeof node === "object" ? node[part] : undefined;
+    }
+    if (typeof node === "string" && node.trim()) value = node.trim();
+  };
+  for (const file of settingsPaths(cwd, opts.settingsFile)) {
+    absorb(readSettingsFile(file, { onWarn: opts.onWarn }));
+  }
+  const managed = loadManagedSettings(opts);
+  if (managed.settings) absorb(managed.settings);
+  return value;
+}
+
 /**
  * Read a string-array setting across the layered `.claude/settings.json` files
  * plus managed settings. Unlike {@link readBooleanSetting} (last-layer wins),
@@ -484,6 +512,7 @@ module.exports = {
   loadSettingsConfig,
   readSettingsFile,
   readBooleanSetting,
+  readStringSetting,
   readStringArraySetting,
   settingsPaths,
   managedSettingsPath,

package/src/repl/agent-repl.js

@@ -185,6 +185,11 @@ import {
   createPromptInteractionSurface,
   mergeClipboardImageChips,
 } from "./prompt-interactions.js";
+import {
+  isReadlineWordRuboutKey,
+  readlineWordRubout,
+  resolveReplKeybindingFlavor,
+} from "./repl-keybindings.js";
 import { createSystemClipboardImageBinding } from "./clipboard-image.js";
 import {
   buildPermissionPrompt,
@@ -2760,15 +2765,11 @@ export async function runReplStartupBoundary(options, startupDependencies) {
         "CC_REPL_STARTUP_DEPENDENCY_INVALID",
       );
     }
-    const root = openBudgetRoot(
-      leaseSessionId,
-      options.sessionBudgetRoot,
-      {
-        persist: true,
-        signal: combineReplSignals(options.signal, leaseScope.lease.signal),
-        table: options.sessionBudgetRoot.table,
-      },
-    );
+    const root = openBudgetRoot(leaseSessionId, options.sessionBudgetRoot, {
+      persist: true,
+      signal: combineReplSignals(options.signal, leaseScope.lease.signal),
+      table: options.sessionBudgetRoot.table,
+    });
     if (
       root?.enabled !== true ||
       !root.budget ||
@@ -2824,10 +2825,7 @@ export function startReplJsonlSession(
       ...meta,
       ...(observabilityScope != null ? { observabilityScope } : {}),
     });
-    if (
-      requireDurable &&
-      (typeof sessionId !== "string" || !sessionId)
-    ) {
+    if (requireDurable && (typeof sessionId !== "string" || !sessionId)) {
       throw new Error("JSONL session creation returned no durable session id");
     }
     return sessionId || null;
@@ -3187,6 +3185,7 @@ async function startAgentReplInWorkspaceOwned(
   let _visionModel;
   let _promptInteractionConfig = {};
   let _persistPromptSuggestionsEnabled = null;
+  let _keybindingFlavor = "classic";
   // Hard stream inactivity timeout override (config.llm.streamStallTimeoutMs,
   // ms): a stream silent that long is aborted + retried instead of hanging.
   // Unset → agent-core's 180s default (matches cc chat/ask). Set to 0 to
@@ -3218,6 +3217,23 @@ async function startAgentReplInWorkspaceOwned(
   } catch {
     /* optional — resolveVisionLlm falls back to DEFAULT_VISION_MODEL */
   }
+  try {
+    const { readStringSetting } = await import("../lib/settings-loader.cjs");
+    const configuredFlavor = readStringSetting("keybindingFlavor", {
+      cwd: process.cwd(),
+      settingsFile: options.settingsFile || null,
+      managedSettingsFile: options.managedSettingsFile || null,
+      onWarn: (message) => logger.warn(message),
+    });
+    const resolvedFlavor = resolveReplKeybindingFlavor(configuredFlavor);
+    _keybindingFlavor = resolvedFlavor.flavor;
+    if (resolvedFlavor.error) {
+      logger.warn(`settings: ${resolvedFlavor.error}; using classic`);
+    }
+  } catch (error) {
+    if (error?.code === "CC_MANAGED_SETTINGS_INVALID") throw error;
+    logger.warn(`settings: could not load keybindingFlavor (${error.message})`);
+  }
   // Extra workspace roots (--add-dir): advertised in the system prompt and
   // spanned by search_files.
   const additionalDirectories = Array.isArray(options.additionalDirectories)
@@ -3815,6 +3831,8 @@ async function startAgentReplInWorkspaceOwned(
       agentSessionId:
         sessionId || `repl-${process.pid}-${Date.now().toString(36)}`,
       isText: false, // the REPL prints its own pairing lines below
+      allowLan: options.remoteControlAllowLan === true,
+      env: process.env,
     });
     _remoteApproval = {
       bridge: started.bridge,
@@ -5201,6 +5219,25 @@ async function startAgentReplInWorkspaceOwned(
         return;
       }
 
+      // 1.875) The opt-in readline flavor makes Ctrl+W a whitespace-delimited
+      // unix-word-rubout. Classic stays byte-identical and lets Node readline
+      // own the chord; Vim NORMAL mode continues to use the existing engine.
+      if (
+        !_turnAbort &&
+        (!_vimEnabled || !_vim) &&
+        _keybindingFlavor === "readline" &&
+        isReadlineWordRuboutKey(_str, k)
+      ) {
+        _consumeReadlineKeypress(key);
+        const next = readlineWordRubout(rl.line, rl.cursor);
+        if (next.changed) {
+          rl.line = next.line;
+          rl.cursor = next.cursor;
+          rl._refreshLine?.();
+        }
+        return;
+      }
+
       // 2) Vim mode: modal editing on the current input line.
       if (_vimEnabled && !_turnAbort) {
         if (!_vim) {
@@ -5625,7 +5662,7 @@ async function startAgentReplInWorkspaceOwned(
         `  ${chalk.cyan("/voice")}      Speech dictation — local-first STT (/voice hold|tap|off)`,
       );
       logger.log(
-        `  ${chalk.cyan("/output-style")} Response persona (/output-style <name|list>; explanatory/learning built-in)`,
+        `  ${chalk.cyan("/output-style")} Response persona (/output-style <name|list>; concise/explanatory/learning built-in)`,
       );
       logger.log(
         `  ${chalk.cyan("/editor")}     Edit a draft prompt in an external editor`,

package/src/repl/permission-prompt.js

@@ -14,15 +14,38 @@
  *
  * @returns {string} the prompt header (no styling, no trailing "Proceed?")
  */
+export function visualizePermissionText(value) {
+  return String(value ?? "").replace(
+    /[\u0000-\u001f\u007f-\u009f\u00ad\u034f\u061c\u115f\u1160\u17b4\u17b5\u180b-\u180f\u200b-\u200f\u202a-\u202e\u2060-\u206f\u3164\ufeff\uffa0]/gu,
+    (character) => {
+      if (character === "\t") return "<TAB>";
+      if (character === "\n") return "<LF>";
+      if (character === "\r") return "<CR>";
+      return `<U+${character.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}>`;
+    },
+  );
+}
+
 export function buildPermissionPrompt({ tool, args, rule, reason } = {}) {
-  const detail = args?.command
-    ? ` ${args.command}`
-    : args?.path
-      ? ` ${args.path}`
-      : "";
-  if (rule) return `[Permission] rule "${rule}" asks before ${tool}:${detail}`;
-  if (reason) return `[Permission] ${reason}`;
-  return `[Permission] confirm ${tool}:${detail}`;
+  const visibleTool = visualizePermissionText(tool);
+  const command = typeof args?.command === "string" ? args.command : "";
+  const source = args?.path ?? args?.file_path ?? args?.source ?? "";
+  const destination = args?.destination ?? args?.new_path ?? args?.to ?? "";
+  const rawDetail = command
+    ? command
+    : source && destination
+      ? `${source} -> ${destination}`
+      : source || destination;
+  const detail = rawDetail ? ` ${visualizePermissionText(rawDetail)}` : "";
+  if (rule) {
+    return `[Permission] rule "${visualizePermissionText(rule)}" asks before ${visibleTool}:${detail}`;
+  }
+  if (reason) {
+    const reasonText = String(reason);
+    const missingTarget = rawDetail && !reasonText.includes(String(rawDetail));
+    return `[Permission] ${visualizePermissionText(reasonText)}${missingTarget ? `:${detail}` : ""}`;
+  }
+  return `[Permission] confirm ${visibleTool}:${detail}`;
 }
 
 /**

package/src/repl/repl-keybindings.js

@@ -1,5 +1,60 @@
 /** Declarative, validated keybindings for interactive prompt actions. */
 
+export const DEFAULT_REPL_KEYBINDING_FLAVOR = "classic";
+export const REPL_KEYBINDING_FLAVORS = Object.freeze([
+  DEFAULT_REPL_KEYBINDING_FLAVOR,
+  "readline",
+]);
+
+/**
+ * Resolve the prompt editing flavor. Unknown values stay on the compatible
+ * classic behavior and include a diagnostic for the caller to surface.
+ */
+export function resolveReplKeybindingFlavor(value) {
+  if (value == null || String(value).trim() === "") {
+    return { flavor: DEFAULT_REPL_KEYBINDING_FLAVOR, error: null };
+  }
+  const flavor = String(value).trim().toLowerCase();
+  if (REPL_KEYBINDING_FLAVORS.includes(flavor)) {
+    return { flavor, error: null };
+  }
+  return {
+    flavor: DEFAULT_REPL_KEYBINDING_FLAVOR,
+    error: `keybindingFlavor must be classic or readline (got "${String(value)}")`,
+  };
+}
+
+/** True for the terminal Ctrl+W chord used by readline's unix-word-rubout. */
+export function isReadlineWordRuboutKey(input, key = {}) {
+  if (key.meta || key.alt || key.shift) return false;
+  const name = String(key.name || "").toLowerCase();
+  return (
+    key.ctrl === true &&
+    (name === "w" || input === "\u0017" || key.sequence === "\u0017")
+  );
+}
+
+/**
+ * Delete the token immediately left of the cursor using whitespace-only word
+ * boundaries. This intentionally treats a full path as one token, unlike the
+ * classic path-segment behavior. Text right of the cursor is preserved.
+ */
+export function readlineWordRubout(line, cursor) {
+  const text = String(line || "");
+  const point = Math.max(
+    0,
+    Math.min(Number.isInteger(cursor) ? cursor : text.length, text.length),
+  );
+  let start = point;
+  while (start > 0 && /\s/u.test(text[start - 1])) start -= 1;
+  while (start > 0 && !/\s/u.test(text[start - 1])) start -= 1;
+  return {
+    line: text.slice(0, start) + text.slice(point),
+    cursor: start,
+    changed: start !== point,
+  };
+}
+
 export const REPL_KEYBINDING_ACTIONS = Object.freeze([
   "prompt.edit",
   "prompt.stash",

package/src/runtime/agent-core.js

@@ -136,6 +136,7 @@ import {
 } from "../harness/structured-handoff.js";
 import { isMcpRpcError } from "../harness/mcp-client.js";
 import { projectCanonicalResumeMessages } from "../lib/session-message-provenance.js";
+import { releaseOldLiveSessionResults } from "../lib/session-runtime-retention.js";
 import {
   pathMatchesOpenedFileIdentitySync,
   sameOpenedFileIdentity,
@@ -12571,6 +12572,7 @@ async function _settleAutomaticCompaction({
   compacted,
   stats,
   options,
+  trigger = "auto",
 }) {
   if (!_sameMessageSnapshot(messages, liveExpectedMessages)) {
     throw _compactionSettlementError(
@@ -12590,7 +12592,7 @@ async function _settleAutomaticCompaction({
     settlement = options.onCompaction(stats, compacted, {
       expectedMessages: authorityExpectedMessages,
       liveExpectedMessages,
-      trigger: "auto",
+      trigger,
     });
   } else if (options.sessionId && options.persistCompaction !== false) {
     const store = await import("../harness/jsonl-session-store.js");
@@ -12605,7 +12607,7 @@ async function _settleAutomaticCompaction({
         options.sessionId,
         {
           ...stats,
-          trigger: "auto",
+          trigger,
           messages: projectCanonicalResumeMessages(compacted, { strict: true }),
         },
         authorityExpectedMessages,
@@ -13180,6 +13182,53 @@ export async function* agentLoop(messages, options) {
       };
     }
 
+    // Release result bodies that have left the recent display window before
+    // every provider admission, independent of the semantic-compaction token
+    // threshold. Settlement persists a bounded resume checkpoint before the
+    // live array changes; the earlier hash-chained result events remain the
+    // durable evidence for audit/recovery.
+    if (options.runtimeResultRetention !== false && messages.length > 32) {
+      const retentionConfig =
+        options.runtimeResultRetention &&
+        typeof options.runtimeResultRetention === "object"
+          ? options.runtimeResultRetention
+          : options.runtimeResultRetentionOptions;
+      const retained = releaseOldLiveSessionResults(messages, retentionConfig);
+      if (
+        retained.stats.released > 0 &&
+        !_sameMessageSnapshot(retained.messages, messages)
+      ) {
+        const authorityExpectedMessages = [...messages];
+        const liveExpectedMessages = [...messages];
+        try {
+          await _settleAutomaticCompaction({
+            messages,
+            liveExpectedMessages,
+            authorityExpectedMessages,
+            compacted: retained.messages,
+            stats: retained.stats,
+            options,
+            trigger: "runtime-retention",
+          });
+          yield {
+            type: "session-runtime-retention",
+            runId,
+            stats: retained.stats,
+          };
+        } catch (error) {
+          yield {
+            type: "session-runtime-retention-degraded",
+            runId,
+            reason:
+              error?.code === "SESSION_REVISION_STALE"
+                ? "session_messages_changed_during_retention"
+                : "canonical_retention_settlement_failed",
+            code: error?.code || "CC_SESSION_RETENTION_SETTLEMENT_FAILED",
+          };
+        }
+      }
+    }
+
     // Headless auto-compaction (Claude-Code `--print` parity). Keeps long
     // `-p` / `--resume` runs under the model's context window instead of
     // growing until the provider rejects the request. Opt-out with