chainlesschain 0.165.4 → 0.165.6

package/src/lib/session-projection.js

@@ -14,8 +14,8 @@ import {
   SESSION_STATES,
 } from "./session-lifecycle.js";
 
-export const SESSION_PROJECTION_SCHEMA = "chainlesschain.session-projection/v1";
-export const SESSION_PROJECTION_VERSION = 1;
+export const SESSION_PROJECTION_SCHEMA = "chainlesschain.session-projection/v2";
+export const SESSION_PROJECTION_VERSION = 2;
 
 export const PROJECTION_KINDS = Object.freeze([
   "local",
@@ -23,6 +23,7 @@ export const PROJECTION_KINDS = Object.freeze([
   "remote",
   "team",
   "workflow",
+  "dynamic_workflow",
 ]);
 
 export const PROJECTION_STATES = Object.freeze([
@@ -43,6 +44,9 @@ export const PROJECTION_ACTIONS = Object.freeze([
   "stop",
   "checkpoint",
   "archive",
+  "pause",
+  "resume",
+  "recover",
 ]);
 
 export const PROJECTION_ACTION_EXECUTORS = Object.freeze([
@@ -115,6 +119,7 @@ function sourceSessionId(source, fallback = null) {
     asText(source?.sessionId) ||
     asText(source?.agentSessionId) ||
     asText(source?.remoteSessionId) ||
+    asText(source?.executionAuthoritySessionId) ||
     fallback
   );
 }
@@ -214,6 +219,22 @@ function mapWorkflowState(source) {
   return "working";
 }
 
+function mapDynamicWorkflowState(source) {
+  const status = String(source?.status || "")
+    .trim()
+    .toLowerCase();
+  if (status === "completed") return "done";
+  if (status === "stopped") return "stopped";
+  if (status === "failed") return "failed";
+  if (["input_requested", "needs_input"].includes(status)) {
+    return "needs_input";
+  }
+  if (["pause_requested", "paused", "blocked"].includes(status)) {
+    return "blocked";
+  }
+  return ["ready", "running"].includes(status) ? "working" : "failed";
+}
+
 function preview(executor, argv, { mutates = false, input = null } = {}) {
   return {
     executor,
@@ -290,6 +311,49 @@ function actionPreviews(kind, state, source, sourceId, linkedSessionId) {
       "--cwd",
       cwd,
     ]);
+  } else if (kind === "dynamic_workflow" && cwd) {
+    const expectedRevision = String(source?.revision || "");
+    const runtimeArgs = (action) => [
+      "cowork",
+      "workflow",
+      `runtime-${action}`,
+      sourceId,
+      "--expected-revision",
+      expectedRevision,
+      "--cwd",
+      cwd,
+      "--json",
+    ];
+    routes.peek = preview("cli", [
+      "cowork",
+      "workflow",
+      "runtime-status",
+      sourceId,
+      "--cwd",
+      cwd,
+      "--json",
+    ]);
+    if (
+      !TERMINAL_PROJECTION_STATES.has(state) &&
+      !["paused", "input_requested", "needs_input"].includes(source?.status)
+    ) {
+      routes.pause = preview("cli", runtimeArgs("pause"), { mutates: true });
+    }
+    if (
+      ["paused", "failed", "blocked"].includes(source?.status) &&
+      Number(source?.agents?.pending || 0) === 0 &&
+      Number(source?.input?.pending || 0) === 0
+    ) {
+      routes.resume = preview("cli", runtimeArgs("resume"), { mutates: true });
+    }
+    if (!["completed", "stopped"].includes(source?.status)) {
+      routes.stop = preview("cli", runtimeArgs("stop"), { mutates: true });
+    }
+    if (Number(source?.recovery?.terminal || 0) > 0) {
+      routes.recover = preview("cli", runtimeArgs("recover-checkpoints"), {
+        mutates: true,
+      });
+    }
   }
 
   if (checkpointAvailable) {
@@ -356,6 +420,18 @@ function actionAvailability(kind, state, source, sourceId, linkedSessionId) {
         : kind === "workflow"
           ? "coding workflow state has no non-destructive archive route"
           : "no non-destructive session archive capability is available",
+    pause:
+      kind === "dynamic_workflow"
+        ? "workflow run cannot be paused in its current state"
+        : "pause is only supported by durable dynamic workflow runs",
+    resume:
+      kind === "dynamic_workflow"
+        ? "workflow run has pending input/effects or is not resumable"
+        : "resume is only supported by durable dynamic workflow runs",
+    recover:
+      kind === "dynamic_workflow"
+        ? "no terminal checkpoint recovery is currently available"
+        : "recovery is only supported by durable dynamic workflow runs",
   };
 
   return PROJECTION_ACTIONS.map((id) => {
@@ -464,6 +540,24 @@ function artifactSummary(sessionIds, artifacts) {
   };
 }
 
+function dynamicWorkflowSummary(source) {
+  if (source?.schema !== "cc-dynamic-workflow-workbench-state/v1") return null;
+  return {
+    runtimeRevision: source.revision,
+    phase: source.phase,
+    agents: source.agents,
+    budget: source.budget,
+    artifacts: source.artifacts,
+    checkpoints: source.checkpoints,
+    recovery: source.recovery,
+    recoveryPolicy: source.recoveryPolicy,
+    recent: source.recent,
+    definitionDigest: source.definitionDigest,
+    admissionDigest: source.admissionDigest,
+    stateDigest: source.stateDigest,
+  };
+}
+
 function prSummary(sessionIds, prLinks) {
   const linked = [];
   for (const sessionId of Array.isArray(sessionIds)
@@ -501,20 +595,57 @@ function approvalSummary(source, state) {
       0,
     );
   }
+  if (source?.schema === "cc-dynamic-workflow-workbench-state/v1") {
+    count +=
+      asCount(source?.input?.pending) + asCount(source?.recovery?.terminal);
+  }
   const needsInput = state === "needs_input";
   return {
     pending: needsInput || state === "blocked" || count > 0,
     type: needsInput
       ? "input"
-      : Array.isArray(source?.units) && count > 0
-        ? "adjudication"
-        : count > 0
-          ? "approval"
-          : null,
+      : source?.schema === "cc-dynamic-workflow-workbench-state/v1" && count > 0
+        ? "recovery"
+        : Array.isArray(source?.units) && count > 0
+          ? "adjudication"
+          : count > 0
+            ? "approval"
+            : null,
     count,
   };
 }
 
+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) ||
@@ -529,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);
@@ -552,7 +687,9 @@ function projectOne(kind, source, { artifacts, prLinks }) {
   if (kind === "local") state = "stopped";
   else if (kind === "team") state = mapTeamState(source);
   else if (kind === "workflow") state = mapWorkflowState(source);
-  else if (kind === "remote") {
+  else if (kind === "dynamic_workflow") {
+    state = mapDynamicWorkflowState(source);
+  } else if (kind === "remote") {
     state = source?.invalid ? "failed" : source?.alive ? "working" : "stopped";
   } else state = mapLifecycleState(source);
 
@@ -583,7 +720,9 @@ function projectOne(kind, source, { artifacts, prLinks }) {
           ? `Team run ${sourceId}`
           : kind === "workflow"
             ? `Workflow ${sourceId}`
-            : `${kind} ${sourceId}`),
+            : kind === "dynamic_workflow"
+              ? `Dynamic workflow ${source?.workflowId || sourceId}`
+              : `${kind} ${sourceId}`),
     capabilities: actions
       .filter((action) => action.available)
       .map((action) => action.id),
@@ -592,9 +731,14 @@ function projectOne(kind, source, { artifacts, prLinks }) {
     owner: ownerSummary(source, kind),
     environment: environmentSummary(source, kind),
     worktree: worktreeSummary(source),
-    artifact: artifactSummary(linkedSessionIds, artifacts),
+    artifact:
+      kind === "dynamic_workflow"
+        ? { 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),
   };
   return { ...projected, revision: projectionRevision(projected) };
@@ -615,12 +759,14 @@ export function buildSessionProjection({
   remote = [],
   team = [],
   workflow = [],
+  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),
@@ -637,6 +783,9 @@ export function buildSessionProjection({
     ...(Array.isArray(workflow) ? workflow : []).map((source) =>
       projectOne("workflow", source, context),
     ),
+    ...(Array.isArray(dynamicWorkflow) ? dynamicWorkflow : []).map((source) =>
+      projectOne("dynamic_workflow", source, context),
+    ),
   ].sort((left, right) => {
     const priority = { needs_input: 0, blocked: 1, working: 2 };
     const rank = (item) => priority[item.state] ?? 3;
@@ -669,6 +818,16 @@ export function buildSessionProjection({
       Array.isArray(workflow) ? workflow.length : 0,
       sourceErrors.workflow,
     ),
+    dynamicWorkflow: sourceStatus(
+      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}`;
 }
 
 /**