@@ -93,6 +93,8 @@ interface ProjectionState {
 }
 
 export interface ResolvedSecretContentProjectionOptions {
+  /** Keeps original logical lines when masking complete text before a file line window. */
+  preserveLineBreaks?: boolean
   /** Values already materialized and verified by a boundary-specific projector. */
   isOpaqueSafeObject?: (value: object) => boolean
   /** Whether string-shaped secret literals should also match typed number/boolean/null values. */
@@ -304,13 +306,13 @@ function sanitizeProjectedString(
       ? sanitizeCollisionProneInternalDiagnosticIdentifiers(value, matcher)
       : value
   sanitized = matcher
-    ? sanitizeResolvedSecretString(sanitized, matcher, maxBytes, options.onMatch)
+    ? sanitizeResolvedSecretString(sanitized, matcher, maxBytes, options.onMatch, options)
     : sanitized
   if (options.sanitizeInternalIdentifiers) {
     sanitized = sanitizeInternalDiagnosticIdentifiers(sanitized)
   }
   if (matcher && containsResolvedSecret(sanitized, matcher)) {
-    sanitized = sanitizeResolvedSecretString(sanitized, matcher, maxBytes, options.onMatch)
+    sanitized = sanitizeResolvedSecretString(sanitized, matcher, maxBytes, options.onMatch, options)
     if (containsResolvedSecret(sanitized, matcher)) {
       throw new ResolvedSecretContentProjectionError(
         'Secret replacement could not produce safe model content'
 
@@ -11,6 +11,31 @@ import {
 const PRESERVE_NAMED_PROVENANCE = { preserveNamedProvenanceLabels: true } as const
 
 describe('resolved secret matcher', () => {
+  it.each([
+    ['first-line\nsecond-line', '{{TOKEN}}\n{{TOKEN}}'],
+    ['first-line\r\nsecond-line', '{{TOKEN}}\r\n{{TOKEN}}'],
+    ['first-line\nsecond-line\n', '{{TOKEN}}\n{{TOKEN}}\n'],
+    ['first-line\n\nsecond-line', '{{TOKEN}}\n{{TOKEN}}\n{{TOKEN}}'],
+    ['\n'.repeat(8), '{{TOKEN}}\n'.repeat(8)],
+  ])(
+    'preserves line boundaries for a complete literal %j when selecting file lines',
+    (plaintext, expected) => {
+      const matcher = createResolvedSecretMatcher([{ plaintext, replacement: '{{TOKEN}}' }])
+      if (!matcher) throw new Error('Fixture literal did not produce a matcher')
+      expect(
+        sanitizeResolvedSecretString(plaintext, matcher, undefined, undefined, {
+          preserveLineBreaks: true,
+        })
+      ).toBe(expected)
+      expect(sanitizeResolvedSecretString(plaintext, matcher)).toBe('{{TOKEN}}')
+      expect(
+        sanitizeResolvedSecretString(`before ${plaintext} after`, matcher, undefined, undefined, {
+          preserveLineBreaks: true,
+        })
+      ).toBe(`before ${expected} after`)
+    }
+  )
+
   it('reports each matched literal once across large repeated content', () => {
     const matcher = createResolvedSecretMatcher([
       { plaintext: 'xxxxxxxx', replacement: '{{SHORT}}' },
 
@@ -293,7 +293,8 @@ export function sanitizeResolvedSecretString(
   value: string,
   matcher: ResolvedSecretMatcher,
   maxBytes = MAX_INLINE_MATERIALIZATION_BYTES,
-  onMatch?: (plaintext: string) => void
+  onMatch?: (plaintext: string) => void,
+  options: { preserveLineBreaks?: boolean } = {}
 ): string {
   /**
    * A substitution can leave a literal the previous pass could not act on: an empty replacement can
@@ -302,12 +303,24 @@ export function sanitizeResolvedSecretString(
    * pathological chain from looping, and the throw past it stays the fail-closed backstop callers
    * already handle by dropping the value.
    */
-  let sanitized = substituteResolvedSecrets(value, matcher, maxBytes, onMatch)
+  let sanitized = substituteResolvedSecrets(
+    value,
+    matcher,
+    maxBytes,
+    onMatch,
+    options.preserveLineBreaks
+  )
   for (let pass = 1; containsResolvedSecret(sanitized, matcher); pass += 1) {
     if (pass >= MAX_SETTLE_PASSES) {
       throw new ResolvedSecretMatcherError('Sanitized content still contains an active secret')
     }
-    sanitized = substituteResolvedSecrets(sanitized, matcher, maxBytes, onMatch)
+    sanitized = substituteResolvedSecrets(
+      sanitized,
+      matcher,
+      maxBytes,
+      onMatch,
+      options.preserveLineBreaks
+    )
   }
   return sanitized
 }
@@ -316,7 +329,8 @@ function substituteResolvedSecrets(
   value: string,
   matcher: ResolvedSecretMatcher,
   maxBytes: number,
-  onMatch?: (plaintext: string) => void
+  onMatch?: (plaintext: string) => void,
+  preserveLineBreaks = false
 ): string {
   if (maxBytes < 0) {
     throw new ResolvedSecretMatcherError('Sanitized secret-bearing string exceeds the size limit')
@@ -356,7 +370,21 @@ function substituteResolvedSecrets(
       const slot = emitCursor % windowSize
       if (slotStarts[slot] === emitCursor && slotReplacements[slot] !== undefined) {
         append(value.slice(literalStart, emitCursor))
-        append(slotReplacements[slot] ?? '')
+        const replacement = slotReplacements[slot] ?? ''
+        if (preserveLineBreaks) {
+          const lineReplacement = replacement.replace(/[\r\n]/g, ' ') || ' '
+          const matched = value.slice(emitCursor, slotEnds[slot])
+          let position = 0
+          while (position < matched.length) {
+            append(lineReplacement)
+            const newline = matched.indexOf('\n', position)
+            if (newline < 0) break
+            append(newline > position && matched[newline - 1] === '\r' ? '\r\n' : '\n')
+            position = newline + 1
+          }
+        } else {
+          append(replacement)
+        }
         emitCursor = slotEnds[slot]
         literalStart = emitCursor
       } else {
 
@@ -10,7 +10,10 @@ import { deleteWorkspaceFixture } from '@sim/db/testing/workspace-fixtures'
 import { generateId } from '@sim/utils/id'
 import { eq, inArray } from 'drizzle-orm'
 import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
-import { observeContentDelivery } from '@/lib/core/application/content-delivery'
+import {
+  observeContentDelivery,
+  observeContentOutsideModel,
+} from '@/lib/core/application/content-delivery'
 import { encryptSecret } from '@/lib/core/security/encryption'
 import {
   createKnowledgeAclFixtureIds,
@@ -117,6 +120,38 @@ afterAll(async () => {
 })
 
 describe('media input version lineage', () => {
+  it.each(['known', 'unknown'] as const)(
+    'preserves the storage size-limit error for an admitted %s media source',
+    async (classification) => {
+      const file = await uploadWorkspaceFile(
+        ids.workspaceId,
+        ids.aliceId,
+        Buffer.from(SECRET),
+        `bounded-${generateId()}.bin`,
+        'application/octet-stream',
+        {
+          secretProvenance: classification === 'known' ? known : { status: 'unknown' },
+          notifyWorkspaceChange: false,
+        }
+      )
+      await expect(
+        observeContentOutsideModel(() =>
+          readWorkspaceFileContent.execute({
+            principal: createCopilotChatPrincipal(
+              { userId: ids.aliceId, workspaceId: ids.workspaceId },
+              WORKSPACE_FILES_DELEGATION_AUDIENCE
+            ),
+            input: { fileId: file.id, maxBytes: 8, includeSecretProvenance: true },
+          })
+        )
+      ).rejects.toMatchObject({
+        name: 'PayloadSizeLimitError',
+        maxBytes: 8,
+        observedBytes: Buffer.byteLength(SECRET),
+      })
+    }
+  )
+
   it.each(['known', 'unknown'] as const)(
     'does not expose storage failures for %s input bytes before a read result exists',
     async (classification) => {