@bahulam/code 2.6.14 → 2.6.15

package/src/ui/input-dock.mjs

@@ -52,6 +52,7 @@ const INPUT_RIGHT_PAD = 2;
 const META_INDENT = 4;
 
 const DEFAULT_MAX_INPUT_ROWS = 6;
+const DEFAULT_OVERLAY_MAX_ROWS = 8;
 const MIN_INPUT_ROWS = 1;
 const MAX_INPUT_ROWS_CAP = 12;
 
@@ -74,8 +75,22 @@ let unsubResize = null;
 let lastFrame = { context: '', meta: '', tips: '', prefix: '', value: '', cursor: null, overlayLines: null };
 let resetting = false;
 let lastGeometry = null;
-
-function write(s) { try { OUT.write(s); } catch {} }
+let contentCursorRow = 1;
+let contentCursorCol = 1;
+let contentTrackingActive = false;
+let suppressWriteTracking = 0;
+let originalStdoutWrite = null;
+let originalStderrWrite = null;
+
+function write(s) {
+  try {
+    suppressWriteTracking++;
+    OUT.write(s);
+  } catch {
+  } finally {
+    suppressWriteTracking = Math.max(0, suppressWriteTracking - 1);
+  }
+}
 function setScrollRegion(top, bottom) { write(`${ESC}${top};${bottom}r`); }
 function clearScrollRegion() { write(`${ESC}r`); }
 function saveCursor() { write(`${ESC}s`); }
@@ -102,6 +117,69 @@ function contentBottomRow() {
   return Math.max(1, rows() - reservedRows);
 }
 
+function clampContentCursor() {
+  const bottom = contentBottomRow();
+  contentCursorRow = Math.max(1, Math.min(bottom, contentCursorRow || 1));
+  contentCursorCol = Math.max(1, Math.min(cols(), contentCursorCol || 1));
+}
+
+function resetContentCursor(row = 1, col = 1) {
+  contentCursorRow = Math.max(1, Math.min(contentBottomRow(), Math.floor(row || 1)));
+  contentCursorCol = Math.max(1, Math.min(cols(), Math.floor(col || 1)));
+}
+
+function trackContentWrite(chunk) {
+  if (!mounted || !contentTrackingActive || suppressWriteTracking > 0) return;
+  const text = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : String(chunk ?? '');
+  if (!text) return;
+  const clean = text
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1b[()][A-Za-z0-9]/g, '');
+  const bottom = contentBottomRow();
+  const width = Math.max(1, drawableColumns());
+  for (const ch of clean) {
+    if (ch === '\r') {
+      contentCursorCol = 1;
+      continue;
+    }
+    if (ch === '\n') {
+      contentCursorRow = Math.min(bottom, contentCursorRow + 1);
+      contentCursorCol = 1;
+      continue;
+    }
+    contentCursorCol++;
+    if (contentCursorCol > width) {
+      contentCursorRow = Math.min(bottom, contentCursorRow + 1);
+      contentCursorCol = 1;
+    }
+  }
+}
+
+function patchOutputTracking() {
+  if (originalStdoutWrite || originalStderrWrite) return;
+  originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  originalStderrWrite = process.stderr.write.bind(process.stderr);
+  process.stdout.write = function trackedStdoutWrite(chunk, ...args) {
+    trackContentWrite(chunk);
+    return originalStdoutWrite(chunk, ...args);
+  };
+  process.stderr.write = function trackedStderrWrite(chunk, ...args) {
+    trackContentWrite(chunk);
+    return originalStderrWrite(chunk, ...args);
+  };
+}
+
+function unpatchOutputTracking() {
+  if (originalStdoutWrite) {
+    process.stdout.write = originalStdoutWrite;
+    originalStdoutWrite = null;
+  }
+  if (originalStderrWrite) {
+    process.stderr.write = originalStderrWrite;
+    originalStderrWrite = null;
+  }
+}
+
 // Row map (top → bottom of the reserved region).
 function topRuleRow()       { return contentBottomRow() + 1; }
 function spacerAboveRow()   { return topRuleRow() + 1; }
@@ -125,6 +203,18 @@ function resolveMaxInputRows(requested) {
   return Math.max(MIN_INPUT_ROWS, Math.min(MAX_INPUT_ROWS_CAP, n));
 }
 
+function resolveOverlayRowCap(requested = DEFAULT_OVERLAY_MAX_ROWS) {
+  const n = Number.parseInt(String(requested), 10);
+  if (!Number.isFinite(n)) return DEFAULT_OVERLAY_MAX_ROWS;
+  return Math.max(MIN_INPUT_ROWS, Math.min(MAX_INPUT_ROWS_CAP, n));
+}
+
+function overlayRowsForWrapped(wrappedLength, requestedMaxRows = DEFAULT_OVERLAY_MAX_ROWS) {
+  const rowCap = resolveOverlayRowCap(requestedMaxRows);
+  const wanted = Math.max(MIN_INPUT_ROWS, Math.floor(Number(wrappedLength) || 0));
+  return Math.min(rowCap, wanted);
+}
+
 // How many input rows does this (prefix + value) buffer need? Wrapped line
 // count clamped to [1, inputRowsMax]. Beyond the cap, tail-with-ellipsis
 // takes over inside drawInputLines so at most inputRowsMax rows render.
@@ -250,6 +340,7 @@ function applyLayout({ clearPrevious = false } = {}) {
   const bottom = contentBottomRow();
   setScrollRegion(1, bottom);
   renderFrame(lastFrame);
+  clampContentCursor();
   // On (re)mount and resize, park at input if we have one; otherwise sit at
   // the bottom of the content region so any pending content writes flush
   // above the dock rather than into a stale mid-frame position.
@@ -385,7 +476,11 @@ export function isInputDockMounted() {
   return mounted;
 }
 
-export function mountInputDock({ inputRowsMax: requestedMax } = {}) {
+export function mountInputDock({
+  inputRowsMax: requestedMax,
+  initialContentRow = 1,
+  initialContentCol = 1,
+} = {}) {
   const t = term();
   if (!t.isTTY || t.plain) return false;
   if (t.ttyMode !== 'rich' || t.fixedInput === false) return false;
@@ -395,7 +490,10 @@ export function mountInputDock({ inputRowsMax: requestedMax } = {}) {
   inputRowsMax = resolveMaxInputRows(requestedMax);
   inputRows = MIN_INPUT_ROWS;
   reservedRows = FIXED_ROWS + inputRows;
+  resetContentCursor(initialContentRow, initialContentCol);
+  contentTrackingActive = false;
   mounted = true;
+  patchOutputTracking();
   applyLayout();
 
   unsubResize = onResize(() => applyLayout({ clearPrevious: true }));
@@ -415,6 +513,8 @@ export function unmountInputDock() {
     if (unsubResize) { unsubResize(); unsubResize = null; }
   } finally {
     mounted = false;
+    contentTrackingActive = false;
+    unpatchOutputTracking();
     resetting = false;
     lastGeometry = null;
   }
@@ -424,17 +524,19 @@ function safeUnmount() { try { unmountInputDock(); } catch {} }
 
 export function moveToContent() {
   if (!mounted) return false;
-  moveTo(contentBottomRow(), 1);
+  clampContentCursor();
+  contentTrackingActive = true;
+  moveTo(contentCursorRow, contentCursorCol);
   return true;
 }
 
-// One row above the bottom of the scroll region. Writes here won't trigger
-// the scroll-on-LF that happens when writing '\n' at the region's bottom row —
-// exactly what the persistent explore/spinner line needs to overwrite in place
-// without piling copies of itself into scrollback.
+// The next transcript row. Spinner/status overlays live next to the latest
+// content instead of near the scroll-region bottom; otherwise sparse agent
+// events leave large blank holes between visible lines.
 export function pinnedStatusRow() {
   if (!mounted) return null;
-  return Math.max(1, contentBottomRow() - 1);
+  clampContentCursor();
+  return Math.max(1, Math.min(contentBottomRow(), contentCursorRow));
 }
 
 export function drawPinnedStatus(line) {
@@ -466,6 +568,7 @@ export function clearPinnedStatus() {
 // clearing their overlay.
 export function redrawDockFrame() {
   if (!mounted) return false;
+  contentTrackingActive = false;
   renderFrame(lastFrame);
   parkCursorAtInput();
   return true;
@@ -473,6 +576,7 @@ export function redrawDockFrame() {
 
 export function prepareInputPrompt({ context = '', tips = '', meta = '' } = {}) {
   if (!mounted) return false;
+  contentTrackingActive = false;
   setInputRowsTo(MIN_INPUT_ROWS);
   clearInputRows();
   renderFrame({ context, tips, meta, prefix: '', value: '', overlayLines: null });
@@ -482,9 +586,11 @@ export function prepareInputPrompt({ context = '', tips = '', meta = '' } = {})
 
 export function clearInputPrompt() {
   if (!mounted) return false;
-  clearInputRows();
+  contentTrackingActive = false;
   lastFrame.value = '';
   lastFrame.overlayLines = null;
+  setInputRowsTo(MIN_INPUT_ROWS);
+  clearInputRows();
   renderFrame(lastFrame);
   parkCursorAtInput();
   return true;
@@ -492,6 +598,7 @@ export function clearInputPrompt() {
 
 export function renderDockInput(prefix, value, { context = '', tips = '', meta = '', cursor = null } = {}) {
   if (!mounted) return false;
+  contentTrackingActive = false;
   setInputRowsTo(computeInputRowsForBuffer(prefix, value));
   renderFrame({ context, tips, meta, prefix, value, cursor, overlayLines: null });
   const layout = layoutInput(prefix, value);
@@ -505,13 +612,14 @@ export function renderDockOverlay({
   lines = [],
   meta = '',
   tips = '',
-  maxRows = 8,
+  maxRows = DEFAULT_OVERLAY_MAX_ROWS,
 } = {}) {
   if (!mounted) return false;
+  contentTrackingActive = false;
   const sourceLines = Array.isArray(lines) ? lines : String(lines || '').split('\n');
   const wrapped = layoutOverlayLines(sourceLines);
-  const rowCap = Math.max(MIN_INPUT_ROWS, Math.min(MAX_INPUT_ROWS_CAP, Math.max(inputRowsMax, maxRows)));
-  setInputRowsTo(Math.min(rowCap, Math.max(MIN_INPUT_ROWS, wrapped.length)), { maxRows: rowCap });
+  const rowCap = resolveOverlayRowCap(maxRows);
+  setInputRowsTo(overlayRowsForWrapped(wrapped.length, rowCap), { maxRows: rowCap });
   const tail = tailWithEllipsis(wrapped, inputRows);
   renderFrame({
     context,
@@ -537,6 +645,7 @@ export function renderDockOverlay({
  */
 export function focusDockInput(prefix, value = '', cursorInValue = null) {
   if (!mounted) return false;
+  contentTrackingActive = false;
   const layout = layoutInput(prefix, value);
   const valueStr = String(value || '');
   const rawCursor = cursorInValue == null
@@ -570,7 +679,12 @@ export function _internals() {
     bottomRuleLine,
     padLine,
     drawableColumns,
+    resetContentCursor,
+    contentCursor: () => ({ row: contentCursorRow, col: contentCursorCol, active: contentTrackingActive }),
+    overlayRowsForWrapped,
     FIXED_ROWS,
+    MAX_INPUT_ROWS_CAP,
+    DEFAULT_OVERLAY_MAX_ROWS,
     BRAND_LABEL,
   };
 }

package/src/ui/tool-card.mjs

@@ -231,32 +231,47 @@ function summarizeJsonOutput(value) {
 
 export function formatCompactFileDiff(result, {
   indent = '  ',
-  maxLines = 14,
-  maxFiles = 2,
+  maxLines = Infinity,
+  maxFiles = Infinity,
   columns = term().columns || 120,
+  showFileHeader = false,
 } = {}) {
-  const diffs = fileDiffs(result).filter(diff => diff?.hunks?.length);
+  const diffs = fileDiffs(result)
+    .map(normalizeFileDiff)
+    .filter(diff => diff && (diff.redacted || diff?.hunks?.length));
   if (!diffs.length) return '';
 
   const out = [];
   let shown = 0;
   let truncated = false;
+  const lineLimit = Number.isFinite(maxLines) ? Math.max(0, Math.floor(maxLines)) : Infinity;
+  const fileLimit = Number.isFinite(maxFiles) ? Math.max(0, Math.floor(maxFiles)) : diffs.length;
   const lineBudget = Math.max(40, columns - visibleWidth(indent) - 4);
 
-  for (const diff of diffs.slice(0, maxFiles)) {
-    if (diffs.length > 1) {
-      if (shown >= maxLines) { truncated = true; break; }
+  for (const diff of diffs.slice(0, fileLimit)) {
+    if (showFileHeader || diffs.length > 1) {
+      if (shown >= lineLimit) { truncated = true; break; }
       out.push(`${indent}${paint.brand.primary(diff.relative_path || diff.path || 'file')} ${paint.text.dim(diffDelta(diff))}`);
       shown++;
     }
 
+    if (diff.redacted) {
+      if (shown >= lineLimit) { truncated = true; break; }
+      const subject = (showFileHeader || diffs.length > 1)
+        ? ''
+        : `${[diff.relative_path || diff.path || 'file', diffDelta(diff)].filter(Boolean).join(' ')} · `;
+      out.push(`${indent}${paint.text.dim(`${subject}diff redacted for sensitive config`)}`);
+      shown++;
+      continue;
+    }
+
     for (const hunk of diff.hunks || []) {
-      if (shown >= maxLines) { truncated = true; break; }
+      if (shown >= lineLimit) { truncated = true; break; }
       out.push(`${indent}${paint.text.dim(`@@ -${hunk.old_start},${hunk.old_count} +${hunk.new_start},${hunk.new_count} @@`)}`);
       shown++;
 
       for (const line of hunk.lines || []) {
-        if (shown >= maxLines) { truncated = true; break; }
+        if (shown >= lineLimit) { truncated = true; break; }
         out.push(`${indent}${paintDiffLine(line, lineBudget)}`);
         shown++;
       }
@@ -265,7 +280,7 @@ export function formatCompactFileDiff(result, {
     if (truncated) break;
   }
 
-  if (diffs.length > maxFiles) truncated = true;
+  if (diffs.length > fileLimit) truncated = true;
   if (truncated) out.push(`${indent}${paint.text.dim('… diff preview truncated; use /last to expand')}`);
   return out.join('\n');
 }
@@ -274,9 +289,112 @@ function fileDiffs(result) {
   if (!result) return [];
   if (Array.isArray(result.file_diffs)) return result.file_diffs;
   if (result.file_diff) return [result.file_diff];
+  if (result.type === 'file_diff' || result.hunks || result.unified) return [result];
   return [];
 }
 
+function normalizeFileDiff(diff) {
+  if (!diff) return null;
+  return {
+    ...diff,
+    hunks: normalizeHunks(diff),
+  };
+}
+
+function normalizeHunks(diff) {
+  if (Array.isArray(diff?.hunks) && diff.hunks.length) {
+    return diff.hunks.map(normalizeHunk).filter(hunk => hunk.lines.length);
+  }
+  if (diff?.unified) return parseUnifiedHunks(diff.unified);
+  return [];
+}
+
+function normalizeHunk(hunk = {}) {
+  const lines = Array.isArray(hunk.lines)
+    ? hunk.lines.map(normalizeDiffLine).filter(Boolean)
+    : typeof hunk.body === 'string'
+      ? parseDiffBody(hunk.body)
+      : [];
+  const oldCount = hunk.old_count ?? hunk.old_lines ?? hunk.oldCount ?? countDiffLines(lines, 'old');
+  const newCount = hunk.new_count ?? hunk.new_lines ?? hunk.newCount ?? countDiffLines(lines, 'new');
+  return {
+    ...hunk,
+    old_start: hunk.old_start ?? hunk.oldStart ?? 1,
+    old_count: oldCount,
+    new_start: hunk.new_start ?? hunk.newStart ?? 1,
+    new_count: newCount,
+    lines,
+  };
+}
+
+function normalizeDiffLine(line) {
+  if (typeof line === 'string') return parseUnifiedLine(line);
+  if (!line || typeof line !== 'object') return null;
+  const rawType = String(line.type || line.kind || '').toLowerCase();
+  const text = String(line.text ?? line.content ?? line.value ?? '');
+  if (rawType === 'add' || rawType === 'added' || rawType === '+') return { ...line, type: 'add', text };
+  if (rawType === 'remove' || rawType === 'removed' || rawType === 'delete' || rawType === '-') return { ...line, type: 'remove', text };
+  if (rawType === 'context' || rawType === 'same' || rawType === ' ') return { ...line, type: 'context', text };
+  return parseUnifiedLine(text);
+}
+
+function parseDiffBody(body) {
+  return String(body || '')
+    .replace(/\r\n?/g, '\n')
+    .split('\n')
+    .filter(line => line && !line.startsWith('@@'))
+    .map(parseUnifiedLine)
+    .filter(Boolean);
+}
+
+function parseUnifiedHunks(unified) {
+  const hunks = [];
+  let current = null;
+  for (const raw of String(unified || '').replace(/\r\n?/g, '\n').split('\n')) {
+    if (raw.startsWith('--- ') || raw.startsWith('+++ ')) continue;
+    const header = raw.match(/^@@\s+-(\d+)(?:,(\d+))?\s+\+(\d+)(?:,(\d+))?\s+@@/);
+    if (header) {
+      current = {
+        old_start: Number(header[1]) || 1,
+        old_count: Number(header[2] || 1),
+        new_start: Number(header[3]) || 1,
+        new_count: Number(header[4] || 1),
+        lines: [],
+      };
+      hunks.push(current);
+      continue;
+    }
+    if (!current) {
+      if (!raw || (!raw.startsWith('+') && !raw.startsWith('-') && !raw.startsWith(' '))) continue;
+      current = { old_start: 1, old_count: 0, new_start: 1, new_count: 0, lines: [] };
+      hunks.push(current);
+    }
+    const line = parseUnifiedLine(raw);
+    if (line) current.lines.push(line);
+  }
+  for (const hunk of hunks) {
+    if (!hunk.old_count) hunk.old_count = countDiffLines(hunk.lines, 'old');
+    if (!hunk.new_count) hunk.new_count = countDiffLines(hunk.lines, 'new');
+  }
+  return hunks.filter(hunk => hunk.lines.length);
+}
+
+function parseUnifiedLine(raw) {
+  const line = String(raw ?? '');
+  if (!line && raw !== '') return null;
+  if (line.startsWith('+') && !line.startsWith('+++')) return { type: 'add', text: line.slice(1) };
+  if (line.startsWith('-') && !line.startsWith('---')) return { type: 'remove', text: line.slice(1) };
+  if (line.startsWith(' ')) return { type: 'context', text: line.slice(1) };
+  return { type: 'context', text: line };
+}
+
+function countDiffLines(lines, side) {
+  return lines.filter(line => {
+    if (side === 'old') return line.type !== 'add';
+    return line.type !== 'remove';
+  }).length;
+}
+
 function paintDiffLine(line, maxWidth) {
   const text = truncatePlain(String(line?.text ?? ''), Math.max(20, maxWidth - 2));
   if (line?.type === 'add') return paint.state.success(`+ ${text}`);
@@ -365,8 +483,19 @@ export function formatCardHead(tool, args, opts = {}) {
   if (tool === 'shell') {
     const profile = shellCommandProfile(toolDisplaySummary(tool, args || {}, { cwd }), { cwd });
     if (profile.compact) {
-      const argsTruncated = truncateMiddle(argsText, budget);
       const head = `${indent}${leadText}`;
+      if (profile.preview) {
+        const fullArgs = compactShellProfile(profile);
+        if (visibleWidth(fullArgs) <= budget) return `${head} ${fullArgs}`;
+        const previewTail = `${paint.text.dim(' · preview:')} ${paint.text.primary(profile.preview)}`;
+        const baseArgs = compactShellProfile(profile, { includePreview: false, includeDetails: false });
+        const baseBudget = budget - visibleWidth(previewTail);
+        if (baseBudget >= 12) {
+          const baseTruncated = truncateEndVisible(baseArgs, baseBudget);
+          return `${head} ${baseTruncated}${previewTail}`;
+        }
+      }
+      const argsTruncated = truncateMiddle(argsText, budget);
       return argsTruncated ? `${head} ${argsTruncated}` : head;
     }
   }
@@ -394,10 +523,15 @@ function formatHeadLead(tool, label) {
   return `${paint.text.dim('• shell ·')} ${paintLabel(tool, label)}`;
 }
 
-function compactShellProfile(profile) {
-  const parts = [`${paint.text.dim('$')} ${paint.text.primary(profile.summary)}`];
+function compactShellProfile(profile, { includePreview = true, includeDetails = true } = {}) {
+  const previewSuffix = profile.preview ? ` · preview: ${profile.preview}` : '';
+  const summary = previewSuffix && profile.summary.endsWith(previewSuffix)
+    ? profile.summary.slice(0, -previewSuffix.length)
+    : profile.summary;
+  const parts = [`${paint.text.dim('$')} ${paint.text.primary(summary)}`];
   if (profile.cwdLabel) parts.push(`${paint.text.dim('in')} ${paint.brand.data(profile.cwdLabel)}`);
-  parts.push(paint.text.dim(profile.detailHint || 'details: F2 or /last'));
+  if (includeDetails) parts.push(paint.text.dim(profile.detailHint || 'details: F2 or /last'));
+  if (includePreview && profile.preview) parts.push(`${paint.text.dim('preview:')} ${paint.text.primary(profile.preview)}`);
   return parts.join(' · ');
 }
 
@@ -478,6 +612,15 @@ function truncateMiddle(text, max) {
   return paint.text.muted(`${head}…${tail}`);
 }
 
+function truncateEndVisible(text, max) {
+  if (!text) return '';
+  if (visibleWidth(text) <= max) return text;
+  const plain = text.replace(/\x1b\[[0-9;]*m/g, '');
+  const limit = Math.max(1, Math.floor(max));
+  if (limit <= 1) return '';
+  return paint.text.muted(`${plain.slice(0, limit - 1)}…`);
+}
+
 function wrapCommand(command, width) {
   const text = String(command || '');
   if (!text) return ['(empty command)'];

package/src/ui/tool-details.mjs

@@ -14,6 +14,7 @@
 import { paint } from './palette.mjs';
 import { icon, toolFamily } from './icons.mjs';
 import { shellCommandProfile, toolDisplayLabel, toolDisplaySummary } from '../terminal/tool-display.mjs';
+import { isSensitiveConfigPath } from '../core/safety.mjs';
 
 const MAX_DETAIL_LINES = 60;
 const MAX_SHELL_DETAIL_LINES = 220;
@@ -136,6 +137,12 @@ function safeDetailArgs(tool, args) {
   }
   if (tool === 'edit_file') {
     const next = { ...args };
+    if (isSensitiveConfigPath(next.file_path || next.path)) {
+      for (const key of ['search', 'replace', 'old_string', 'new_string']) {
+        if (typeof next[key] === 'string') next[key] = '[redacted]';
+      }
+      return next;
+    }
     for (const key of ['search', 'replace', 'old_string', 'new_string']) {
       if (typeof next[key] === 'string' && next[key].length > 80) {
         next[key] = `[${next[key].split('\n').length} lines omitted]`;
@@ -213,7 +220,16 @@ function detailListFiles(card) {
 // ── Write / edit ────────────────────────────────────────────────────────
 
 function detailEditFile(card) {
-  const diff = card.result?.file_diff?.unified || card.result?.diff || card.result?.patch || card.result?.output;
+  const redacted = redactedFileDiff(card.result?.file_diff)
+    || (isSensitiveConfigPath(card.args?.file_path || card.args?.path)
+      ? sensitiveFallbackDiff(card)
+      : null);
+  if (redacted) return renderRedactedDiff(redacted);
+
+  const diff = unifiedForFileDiff(card.result?.file_diff)
+    || card.result?.diff
+    || card.result?.patch
+    || card.result?.output;
   if (diff) return renderDiff(String(diff));
 
   const before = card.args?.search;
@@ -228,7 +244,13 @@ function detailEditFile(card) {
 }
 
 function detailWriteFile(card) {
-  const diff = card.result?.file_diff?.unified || card.result?.diff;
+  const redacted = redactedFileDiff(card.result?.file_diff)
+    || (isSensitiveConfigPath(card.args?.file_path || card.args?.path)
+      ? sensitiveFallbackDiff(card)
+      : null);
+  if (redacted) return renderRedactedDiff(redacted);
+
+  const diff = unifiedForFileDiff(card.result?.file_diff) || card.result?.diff;
   if (diff) return renderDiff(String(diff));
   const content = card.args?.content;
   if (!content) return paint.text.dim('    (no content)');
@@ -238,7 +260,12 @@ function detailWriteFile(card) {
 function detailWriteProject(card) {
   const diffs = card.result?.file_diffs || [];
   if (diffs.length) {
-    return renderDiff(diffs.map(diff => diff.unified).filter(Boolean).join('\n'));
+    return diffs.map(diff => {
+      const redacted = redactedFileDiff(diff);
+      if (redacted) return renderRedactedDiff(redacted);
+      const unified = unifiedForFileDiff(diff);
+      return unified ? renderDiff(unified) : '';
+    }).filter(Boolean).join('\n');
   }
   const files = card.args?.files || [];
   if (!files.length) return paint.text.dim('    (no files)');
@@ -249,6 +276,26 @@ function detailWriteProject(card) {
   }).join('\n');
 }
 
+function redactedFileDiff(diff) {
+  return diff?.redacted ? diff : null;
+}
+
+function sensitiveFallbackDiff(card) {
+  return {
+    relative_path: card.args?.file_path || card.args?.path || 'sensitive config',
+    lines_added: card.result?.lines_added,
+    lines_removed: card.result?.lines_removed,
+    redacted: true,
+  };
+}
+
+function renderRedactedDiff(diff = {}) {
+  const file = diff.relative_path || diff.path || 'sensitive config';
+  const add = diff.lines_added ?? 0;
+  const rem = diff.lines_removed ?? 0;
+  return `    ${paint.brand.primary(file)} ${paint.text.dim(`+${add} −${rem}`)}\n    ${paint.text.dim('diff redacted for sensitive config')}`;
+}
+
 function detailDeleteFile(card) {
   const p = card.args?.file_path || card.args?.path || '';
   return `    ${paint.state.danger('✗')} ${paint.text.primary(p)}`;
@@ -405,6 +452,52 @@ function renderDiff(text) {
   }).join('\n');
 }
 
+function unifiedForFileDiff(diff) {
+  if (!diff) return '';
+  if (diff.unified) return String(diff.unified);
+  const hunks = Array.isArray(diff.hunks) ? diff.hunks : [];
+  if (!hunks.length) return '';
+  const file = diff.relative_path || diff.path || 'file';
+  const out = [`--- a/${file}`, `+++ b/${file}`];
+  for (const hunk of hunks) {
+    const lines = hunkLines(hunk);
+    if (!lines.length) continue;
+    const oldCount = hunk.old_count ?? hunk.old_lines ?? countLinesForSide(lines, 'old');
+    const newCount = hunk.new_count ?? hunk.new_lines ?? countLinesForSide(lines, 'new');
+    out.push(`@@ -${hunk.old_start ?? 1},${oldCount} +${hunk.new_start ?? 1},${newCount} @@`);
+    for (const line of lines) out.push(toUnifiedLine(line));
+  }
+  return out.length > 2 ? out.join('\n') : '';
+}
+
+function hunkLines(hunk = {}) {
+  if (Array.isArray(hunk.lines)) return hunk.lines;
+  if (typeof hunk.body !== 'string') return [];
+  return hunk.body.replace(/\r\n?/g, '\n').split('\n').filter(line => line && !line.startsWith('@@'));
+}
+
+function toUnifiedLine(line) {
+  if (typeof line === 'string') {
+    if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) return line;
+    return ` ${line}`;
+  }
+  const type = String(line?.type || '').toLowerCase();
+  const text = String(line?.text ?? line?.content ?? '');
+  if (type === 'add' || type === 'added') return `+${text}`;
+  if (type === 'remove' || type === 'removed' || type === 'delete') return `-${text}`;
+  return ` ${text}`;
+}
+
+function countLinesForSide(lines, side) {
+  return lines.filter(line => {
+    const type = typeof line === 'string'
+      ? (line.startsWith('+') ? 'add' : line.startsWith('-') ? 'remove' : 'context')
+      : String(line?.type || 'context').toLowerCase();
+    if (side === 'old') return type !== 'add' && type !== 'added';
+    return type !== 'remove' && type !== 'removed' && type !== 'delete';
+  }).length;
+}
+
 function formatDuration(ms) {
   if (ms < 1000) return `${Math.round(ms)}ms`;
   return `${(ms / 1000).toFixed(1)}s`;