chainlesschain 0.163.8 → 0.165.1

package/src/repl/ide-status.js

@@ -45,7 +45,7 @@ export function renderIdeStatus(mcp, diag = null) {
     lines.push(`  tools: ${tools.map((t) => IDE_PREFIX + t).join(", ")}`);
     lines.push(
       "  selection/diagnostics auto-share each turn · " +
-        "@selection / @diagnostics expand on demand",
+        "@selection / @diagnostics / @terminal / @context expand on demand",
     );
     return lines.join("\n");
   }

package/src/repl/prompt-interactions.js

@@ -18,6 +18,8 @@ import {
 } from "./repl-keybindings.js";
 import {
   detectClipboardImageCapability,
+  MAX_CLIPBOARD_IMAGE_ATTACHMENTS,
+  MAX_CLIPBOARD_IMAGE_TOTAL_BYTES,
   readClipboardImageChip,
 } from "./clipboard-image.js";
 import { layoutTerminalText } from "./terminal-layout.js";
@@ -36,6 +38,12 @@ function safeErrorText(value) {
     .join("\n");
 }
 
+function boundedClipboardQueueLimit(value, fallback, maximum) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed <= 0) return fallback;
+  return Math.min(parsed, maximum);
+}
+
 export const PROMPT_INTERACTION_SLASH_COMMANDS = Object.freeze([
   Object.freeze({
     name: "/recap",
@@ -136,6 +144,17 @@ export class PromptInteractionController {
     this.persistSuggestionEnabled = options.persistSuggestionEnabled;
     this.clipboardBinding = options.clipboardBinding || null;
     this.clipboardImageChips = [];
+    this.clipboardImageBytes = 0;
+    this.maxClipboardImageAttachments = boundedClipboardQueueLimit(
+      options.maxClipboardImageAttachments,
+      MAX_CLIPBOARD_IMAGE_ATTACHMENTS,
+      MAX_CLIPBOARD_IMAGE_ATTACHMENTS,
+    );
+    this.maxClipboardImageTotalBytes = boundedClipboardQueueLimit(
+      options.maxClipboardImageTotalBytes,
+      MAX_CLIPBOARD_IMAGE_TOTAL_BYTES,
+      MAX_CLIPBOARD_IMAGE_TOTAL_BYTES,
+    );
 
     const validated = validateReplKeybindings(options.keybindings || {});
     this.keybindingDiagnostics = validated.errors.slice();
@@ -279,12 +298,38 @@ export class PromptInteractionController {
         this._print(result.reason, { error: true });
         return { handled: true, action: "paste-image", ...result };
       }
-      const result = await readClipboardImageChip(this.clipboardBinding);
+      if (
+        this.clipboardImageChips.length >= this.maxClipboardImageAttachments
+      ) {
+        const result = {
+          ok: false,
+          supported: true,
+          mode: detectClipboardImageCapability(this.clipboardBinding).mode,
+          reason: `Clipboard attachment queue is limited to ${this.maxClipboardImageAttachments} images.`,
+        };
+        this._print(result.reason, { error: true });
+        return { handled: true, action: "paste-image", ...result };
+      }
+      let result = await readClipboardImageChip(this.clipboardBinding);
       if (result.ok) {
-        this.clipboardImageChips.push(result.chip);
-        this._print(
-          `Image attached from clipboard (${result.mediaType}, ${result.bytes} bytes).`,
-        );
+        if (
+          this.clipboardImageBytes + result.bytes >
+          this.maxClipboardImageTotalBytes
+        ) {
+          result = {
+            ok: false,
+            supported: true,
+            mode: result.mode,
+            reason: `Clipboard attachment queue exceeds ${this.maxClipboardImageTotalBytes} bytes.`,
+          };
+          this._print(result.reason, { error: true });
+        } else {
+          this.clipboardImageChips.push(result.chip);
+          this.clipboardImageBytes += result.bytes;
+          this._print(
+            `Image attached from clipboard (${result.mediaType}, ${result.bytes} bytes).`,
+          );
+        }
       } else {
         this._print(result.reason, { error: true });
       }
@@ -371,12 +416,20 @@ export class PromptInteractionController {
   takeClipboardImageChips() {
     const chips = this.clipboardImageChips.slice();
     this.clipboardImageChips.length = 0;
+    this.clipboardImageBytes = 0;
     return chips;
   }
 
+  clearClipboardImageChips() {
+    const cleared = this.clipboardImageChips.length;
+    this.clipboardImageChips.length = 0;
+    this.clipboardImageBytes = 0;
+    return cleared;
+  }
+
   dispose() {
     this.suggestions.dispose();
-    this.clipboardImageChips.length = 0;
+    this.clearClipboardImageChips();
   }
 }
 

package/src/repl/remote-approval.js

@@ -19,14 +19,21 @@
 /**
  * Normalize the shapes the REPL's two confirmers receive (ApprovalGate
  * `{tool, args, riskLevel}` / settings-hook `{tool, args, rule, reason}`)
- * into the bridge's `{tool, action, detail}` ask payload.
+ * into the bridge's exact durable ask payload.
  */
 export function describeAskContext({
   tool,
   args,
+  action = null,
   rule = null,
   reason = null,
   riskLevel = null,
+  cwd = null,
+  workspace = null,
+  sessionId = null,
+  session = null,
+  targetEnv = null,
+  policyVersion = null,
 } = {}) {
   const detail =
     typeof args?.command === "string"
@@ -38,17 +45,24 @@ export function describeAskContext({
           : null;
   return {
     tool: tool || null,
-    action: rule
-      ? `ask-rule:${rule}`
-      : reason || (riskLevel ? `${riskLevel}-risk` : null),
+    action:
+      action ||
+      (rule
+        ? `ask-rule:${rule}`
+        : reason || (riskLevel ? `${riskLevel}-risk` : null)),
     detail,
+    operationArgs: args === undefined ? null : structuredClone(args),
+    workspace: workspace || cwd || null,
+    session: session || sessionId || null,
+    targetEnv: targetEnv || null,
+    policyVersion: policyVersion || null,
   };
 }
 
 // These outcomes are not a remote human decision. The terminal may still
 // answer, but its result is accepted only if resolveLocally can durably settle
 // the same live card.
-const NON_DECISIVE_REMOTE = new Set(["timeout", "closed"]);
+const NON_DECISIVE_REMOTE = new Set(["timeout", "closed", "lease-unavailable"]);
 
 /**
  * Race the local interactive prompt against the paired-device decision.
@@ -83,14 +97,22 @@ export async function raceLocalAndRemote({
     () => ({ src: "local", approved: false }),
   );
   let winner = await Promise.race([remoteLeg, localLeg]);
+  let remoteUnavailableWithoutCard = false;
   if (
     winner.src === "remote" &&
     NON_DECISIVE_REMOTE.has(winner.decision?.via)
   ) {
+    remoteUnavailableWithoutCard =
+      winner.decision?.via === "lease-unavailable" && !requestId;
     winner = await localLeg;
   }
   if (winner.src === "local") {
-    if (!requestId) return false;
+    // Unsupported tools have no durable remote card to settle. In that exact
+    // lease-unavailable case, preserve the existing local confirmation path;
+    // timeout/closed responses without a request id remain fail-closed.
+    if (!requestId) {
+      return remoteUnavailableWithoutCard && winner.approved === true;
+    }
     try {
       const persisted = bridge.resolveLocally(requestId, winner.approved);
       return persisted === true && winner.approved === true;
@@ -107,5 +129,5 @@ export async function raceLocalAndRemote({
   writeOut(
     `\n  ✓ ${winner.decision.approved ? "allowed" : "denied"} from paired device\n`,
   );
-  return winner.decision.approved === true;
+  return winner.decision;
 }