diff --git a/app/api/calculate/route.ts b/app/api/calculate/route.ts
index 85501d2..0f1e574 100644
--- a/app/api/calculate/route.ts
+++ b/app/api/calculate/route.ts
@@ -22,6 +22,7 @@ export async function POST(request: NextRequest) {
 
     return NextResponse.json({
       success: true,
+      calculation,
       ...calculation,
     });
   } catch (error: any) {
diff --git a/app/api/contributions/route.ts b/app/api/contributions/route.ts
new file mode 100644
index 0000000..ae6217b
--- /dev/null
+++ b/app/api/contributions/route.ts
@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { sessionManager } from '@/lib/services/SessionManager';
+import { gitHubApiClient } from '@/lib/services/GitHubApiClient';
+
+export async function GET(request: NextRequest) {
+  const cookieValue = request.cookies.get(sessionManager.getSessionCookieName())?.value;
+  const user = sessionManager.parseUser(cookieValue);
+
+  if (!user || !user.login) {
+    return NextResponse.json(
+      { success: false, message: 'GitHub sign-in is required.' },
+      { status: 401 }
+    );
+  }
+
+  try {
+    const contributions = await gitHubApiClient.fetchContributionCalendar(
+      user.login,
+      user.accessToken
+    );
+
+    return NextResponse.json({
+      success: true,
+      user: user.login,
+      contributions,
+      totalActiveDays: Object.keys(contributions).length,
+    });
+  } catch (error: any) {
+    return NextResponse.json(
+      { success: false, message: error.message || 'Failed to fetch contribution calendar' },
+      { status: error.status || 500 }
+    );
+  }
+}
diff --git a/app/components/HeatmapCanvas.tsx b/app/components/HeatmapCanvas.tsx
index 6ef2bdd..49f4d85 100644
--- a/app/components/HeatmapCanvas.tsx
+++ b/app/components/HeatmapCanvas.tsx
@@ -10,14 +10,19 @@ import {
   Shuffle, 
   Check, 
   Hand, 
-  X 
+  X,
+  ShieldCheck,
+  ShieldAlert
 } from 'lucide-react';
 import { Button } from '@/app/components/ui/Button';
 import { Badge } from '@/app/components/ui/Badge';
 
-interface HeatmapCanvasProps {
+export interface HeatmapCanvasProps {
   matrix: CustomCommitMatrix;
   onChange: (matrix: CustomCommitMatrix) => void;
+  existingContributions?: Record<string, number>;
+  protectExisting?: boolean;
+  onToggleProtectExisting?: (protect: boolean) => void;
 }
 
 const LEVEL_COLORS: Record<number, string> = {
@@ -28,6 +33,14 @@ const LEVEL_COLORS: Record<number, string> = {
   4: '#39d353', // Ultra (10 commits)
 };
 
+const EXISTING_LEVEL_COLORS: Record<number, string> = {
+  0: '#161b22',
+  1: 'rgba(6, 182, 212, 0.40)', // Cyan 500 subtle
+  2: 'rgba(6, 182, 212, 0.65)', // Cyan 500 medium
+  3: 'rgba(14, 165, 233, 0.85)', // Sky 500 strong
+  4: '#06b6d4',                  // Cyan 500 full glow
+};
+
 const LEVEL_COMMITS: Record<number, number> = {
   0: 0,
   1: 1,
@@ -39,11 +52,23 @@ const LEVEL_COMMITS: Record<number, number> = {
 const MONTH_NAMES = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
 const DAY_LABELS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
 
-export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
+export function HeatmapCanvas({ 
+  matrix, 
+  onChange,
+  existingContributions = {},
+  protectExisting = true,
+  onToggleProtectExisting
+}: HeatmapCanvasProps) {
   const [selectedBrush, setSelectedBrush] = useState<number>(3); // default Level 3
   const [isMouseDown, setIsMouseDown] = useState<boolean>(false);
   const [touchMode, setTouchMode] = useState<'draw' | 'pan'>('draw');
-  const [hoveredCell, setHoveredCell] = useState<{ date: string; day: string; count: number; level: number } | null>(null);
+  const [hoveredCell, setHoveredCell] = useState<{ 
+    date: string; 
+    day: string; 
+    count: number; 
+    level: number;
+    isProtected?: boolean;
+  } | null>(null);
 
   // Responsive full-width container tracking
   const containerRef = useRef<HTMLDivElement>(null);
@@ -110,14 +135,20 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
   }, []);
 
   const paintCell = useCallback((dateStr: string, level: number) => {
+    if (protectExisting && (existingContributions[dateStr] || 0) > 0) {
+      return; // Cell is protected with existing contributions
+    }
     const count = LEVEL_COMMITS[level] || 0;
     onChange({
       ...matrix,
       [dateStr]: count,
     });
-  }, [matrix, onChange]);
+  }, [matrix, onChange, protectExisting, existingContributions]);
 
   const handleCellPointerDown = (dateStr: string) => {
+    if (protectExisting && (existingContributions[dateStr] || 0) > 0) {
+      return; // Do not paint on protected cell
+    }
     setIsMouseDown(true);
     if (touchMode === 'draw') {
       paintCell(dateStr, selectedBrush);
@@ -125,6 +156,9 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
   };
 
   const handleCellPointerEnter = (dateStr: string) => {
+    if (protectExisting && (existingContributions[dateStr] || 0) > 0) {
+      return; // Do not paint on protected cell
+    }
     if (isMouseDown && touchMode === 'draw') {
       paintCell(dateStr, selectedBrush);
     }
@@ -138,6 +172,9 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
     const newMatrix: CustomCommitMatrix = {};
     calendarGrid.forEach(week => {
       week.forEach(cell => {
+        if (protectExisting && (existingContributions[cell.dateStr] || 0) > 0) {
+          return; // Skip protected cells
+        }
         const curCount = matrix[cell.dateStr] || 0;
         newMatrix[cell.dateStr] = curCount > 0 ? 0 : LEVEL_COMMITS[selectedBrush || 3];
       });
@@ -149,6 +186,9 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
     const newMatrix: CustomCommitMatrix = {};
     calendarGrid.forEach(week => {
       week.forEach(cell => {
+        if (protectExisting && (existingContributions[cell.dateStr] || 0) > 0) {
+          return; // Skip protected cells
+        }
         const isWeekend = cell.dayIndex === 0 || cell.dayIndex === 6;
         const chance = isWeekend ? 0.2 : 0.65;
         if (Math.random() < chance) {
@@ -183,6 +223,9 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
         if (weekIdx < 52 && calendarGrid[weekIdx]) {
           const cell = calendarGrid[weekIdx][r];
           if (cell) {
+            if (protectExisting && (existingContributions[cell.dateStr] || 0) > 0) {
+              continue; // Do not overwrite protected cells with stencil
+            }
             const isFilled = rows[r]?.[c];
             if (isFilled) {
               newMatrix[cell.dateStr] = LEVEL_COMMITS[selectedBrush || 3];
@@ -314,6 +357,30 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
             <span>{touchMode === 'draw' ? 'Draw Mode' : 'Pan Mode'}</span>
           </button>
 
+          {/* Protect Original Contributions Toggle */}
+          {onToggleProtectExisting && (
+            <button
+              type="button"
+              onClick={() => onToggleProtectExisting(!protectExisting)}
+              className={`btn btn-sm ${protectExisting ? 'btn-secondary' : 'btn-ghost'}`}
+              style={{
+                fontSize: '0.75rem',
+                padding: '0.4rem 0.75rem',
+                display: 'flex',
+                alignItems: 'center',
+                gap: '0.35rem',
+                border: protectExisting ? '1px solid rgba(6, 182, 212, 0.4)' : undefined,
+                background: protectExisting ? 'rgba(6, 182, 212, 0.12)' : undefined,
+                color: protectExisting ? 'var(--cyan-400)' : 'var(--text-secondary)',
+              }}
+              title="Protect original GitHub contributions from being overwritten"
+              aria-label={`Toggle protection of existing contributions, current: ${protectExisting ? 'active' : 'inactive'}`}
+            >
+              {protectExisting ? <ShieldCheck size={13} color="var(--cyan-400)" /> : <ShieldAlert size={13} />}
+              <span>{protectExisting ? 'Original Protected' : 'Protection Off'}</span>
+            </button>
+          )}
+
           {/* Stencil */}
           <Button
             variant="primary"
@@ -452,36 +519,61 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
                   }}
                 >
                   {week.map((cell) => {
-                    const count = matrix[cell.dateStr] || 0;
+                    const originalCount = existingContributions[cell.dateStr] || 0;
+                    const isCellProtected = Boolean(protectExisting && originalCount > 0);
+                    const count = isCellProtected ? originalCount : (matrix[cell.dateStr] || 0);
+
                     let level = 0;
                     if (count >= 10) level = 4;
                     else if (count >= 6) level = 3;
                     else if (count >= 3) level = 2;
                     else if (count > 0) level = 1;
 
+                    const cellBg = isCellProtected
+                      ? EXISTING_LEVEL_COLORS[level]
+                      : LEVEL_COLORS[level];
+
+                    const cellBorder = isCellProtected
+                      ? '1px solid rgba(6, 182, 212, 0.45)'
+                      : level > 0
+                        ? '1px solid rgba(255, 255, 255, 0.16)'
+                        : '1px solid rgba(255, 255, 255, 0.04)';
+
+                    const cellCursor = isCellProtected
+                      ? 'not-allowed'
+                      : touchMode === 'draw'
+                        ? 'crosshair'
+                        : 'default';
+
                     return (
                       <div
                         key={cell.dateStr}
                         data-date={cell.dateStr}
                         role="button"
                         tabIndex={-1}
-                        aria-label={`${cell.dateStr}: ${count} commits`}
+                        aria-label={`${cell.dateStr}: ${count} ${isCellProtected ? 'original' : 'planned'} commits`}
                         onPointerDown={() => {
-                          handleCellPointerDown(cell.dateStr);
+                          if (!isCellProtected) {
+                            handleCellPointerDown(cell.dateStr);
+                          }
                           setHoveredCell({
                             date: cell.dateStr,
                             day: DAY_LABELS[cell.dayIndex],
-                            count: LEVEL_COMMITS[selectedBrush] ?? count,
-                            level: selectedBrush,
+                            count: isCellProtected ? originalCount : (LEVEL_COMMITS[selectedBrush] ?? count),
+                            level: isCellProtected ? level : selectedBrush,
+                            isProtected: isCellProtected,
                           });
                         }}
                         onPointerEnter={() => {
-                          handleCellPointerEnter(cell.dateStr);
+                          if (!isCellProtected) {
+                            handleCellPointerEnter(cell.dateStr);
+                          }
                           setHoveredCell({
                             date: cell.dateStr,
                             day: DAY_LABELS[cell.dayIndex],
                             count,
                             level,
+                            isProtected: isCellProtected,
                           });
                         }}
                         onPointerLeave={() => {
@@ -493,9 +585,10 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
                           width: `${cellSize}px`,
                           height: `${cellSize}px`,
                           borderRadius: '2.5px',
-                          backgroundColor: LEVEL_COLORS[level],
-                          border: level > 0 ? '1px solid rgba(255, 255, 255, 0.16)' : '1px solid rgba(255, 255, 255, 0.04)',
-                          cursor: touchMode === 'draw' ? 'crosshair' : 'default',
+                          backgroundColor: cellBg,
+                          border: cellBorder,
+                          cursor: cellCursor,
+                          boxShadow: isCellProtected && level >= 3 ? '0 0 6px rgba(6, 182, 212, 0.35)' : 'none',
                           transition: 'transform 0.08s var(--spring-ease), background-color 0.12s ease',
                           touchAction: touchMode === 'draw' ? 'none' : 'auto',
                         }}
@@ -533,9 +626,15 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
             Inspecting:
           </span>
           {hoveredCell ? (
-            <Badge variant="emerald">
-              {hoveredCell.date} ({hoveredCell.day}) • {hoveredCell.count} commits (L{hoveredCell.level})
-            </Badge>
+            hoveredCell.isProtected ? (
+              <Badge variant="cyan">
+                🔒 {hoveredCell.date} ({hoveredCell.day}) • {hoveredCell.count} original commits (Protected)
+              </Badge>
+            ) : (
+              <Badge variant="emerald">
+                {hoveredCell.date} ({hoveredCell.day}) • {hoveredCell.count} commits (L{hoveredCell.level})
+              </Badge>
+            )
           ) : (
             <span style={{ color: 'var(--text-disabled)', fontFamily: 'var(--font-mono)' }}>
               Hover or tap any square
@@ -544,22 +643,39 @@ export function HeatmapCanvas({ matrix, onChange }: HeatmapCanvasProps) {
         </div>
 
         {/* Legend */}
-        <div style={{ display: 'flex', alignItems: 'center', gap: '0.4rem', color: 'var(--text-muted)', fontSize: '0.75rem' }}>
-          <span>Less</span>
-          {[0, 1, 2, 3, 4].map(lv => (
-            <span
-              key={lv}
-              style={{
-                width: '11px',
-                height: '11px',
-                borderRadius: '2px',
-                backgroundColor: LEVEL_COLORS[lv],
-                display: 'inline-block',
-                border: '1px solid rgba(255, 255, 255, 0.12)',
-              }}
-            />
-          ))}
-          <span>More</span>
+        <div style={{ display: 'flex', alignItems: 'center', gap: '0.9rem', color: 'var(--text-muted)', fontSize: '0.75rem', flexWrap: 'wrap' }}>
+          {protectExisting && (
+            <div style={{ display: 'flex', alignItems: 'center', gap: '0.35rem' }}>
+              <span
+                style={{
+                  width: '11px',
+                  height: '11px',
+                  borderRadius: '2px',
+                  backgroundColor: EXISTING_LEVEL_COLORS[3],
+                  display: 'inline-block',
+                  border: '1px solid rgba(6, 182, 212, 0.5)',
+                }}
+              />
+              <span style={{ color: 'var(--cyan-400)', fontWeight: 600 }}>Original (Protected)</span>
+            </div>
+          )}
+          <div style={{ display: 'flex', alignItems: 'center', gap: '0.35rem' }}>
+            <span>Less</span>
+            {[0, 1, 2, 3, 4].map(lv => (
+              <span
+                key={lv}
+                style={{
+                  width: '11px',
+                  height: '11px',
+                  borderRadius: '2px',
+                  backgroundColor: LEVEL_COLORS[lv],
+                  display: 'inline-block',
+                  border: '1px solid rgba(255, 255, 255, 0.12)',
+                }}
+              />
+            ))}
+            <span>More</span>
+          </div>
         </div>
       </div>
 
diff --git a/app/dashboard/page.tsx b/app/dashboard/page.tsx
index 9a82a9e..558d506 100644
--- a/app/dashboard/page.tsx
+++ b/app/dashboard/page.tsx
@@ -105,6 +105,11 @@ export default function DashboardPage() {
   const [showProgressModal, setShowProgressModal] = useState<boolean>(false);
   const [startingJob, setStartingJob] = useState<boolean>(false);
 
+  // Original GitHub contributions & protection
+  const [existingContributions, setExistingContributions] = useState<Record<string, number>>({});
+  const [protectExisting, setProtectExisting] = useState<boolean>(true);
+  const [loadingContributions, setLoadingContributions] = useState<boolean>(false);
+
   const isPausedRef = useRef<boolean>(false);
   const cancelRef = useRef<boolean>(false);
   const batchStateRef = useRef<{
@@ -131,6 +136,7 @@ export default function DashboardPage() {
           setRepoOwner(data.user.login);
           setLoadingAuth(false);
           loadRepositories();
+          loadContributions();
         } else {
           router.replace('/auth');
         }
@@ -160,6 +166,21 @@ export default function DashboardPage() {
     }
   };
 
+  const loadContributions = async () => {
+    setLoadingContributions(true);
+    try {
+      const res = await fetch('/api/contributions');
+      const data = await res.json();
+      if (data.success && data.contributions) {
+        setExistingContributions(data.contributions);
+      }
+    } catch (err) {
+      console.warn('Failed to load contributions:', err);
+    } finally {
+      setLoadingContributions(false);
+    }
+  };
+
   const handleSelectRepo = (repoName: string) => {
     setSelectedRepo(repoName);
     const found = repositories.find((r) => r.name === repoName);
@@ -185,10 +206,15 @@ export default function DashboardPage() {
     return Object.values(customMatrix).filter(c => (c || 0) > 0).length;
   }, [customMatrix]);
 
+  const originalActiveDays = useMemo(() => {
+    return Object.keys(existingContributions).filter(d => (existingContributions[d] || 0) > 0).length;
+  }, [existingContributions]);
+
   // Pre-flight calculation
   const handleCalculateSchedule = async () => {
     setCalculating(true);
     try {
+      const lockedDates = Object.keys(existingContributions).filter(d => (existingContributions[d] || 0) > 0);
       const res = await fetch('/api/calculate', {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
@@ -202,12 +228,15 @@ export default function DashboardPage() {
           pushToRemote,
           weekdayCounts,
           customMatrix,
+          lockedDates,
+          protectExisting,
         }),
       });
 
       const data = await res.json();
-      if (data.success && data.calculation) {
-        setCalculation(data.calculation);
+      const calcResult = data.calculation || data;
+      if (data.success && calcResult) {
+        setCalculation(calcResult);
         setShowSummaryModal(true);
       } else {
         alert(data.message || 'Failed to calculate schedule');
@@ -333,6 +362,7 @@ export default function DashboardPage() {
     setShowProgressModal(true);
 
     try {
+      const lockedDates = Object.keys(existingContributions).filter(d => (existingContributions[d] || 0) > 0);
       const config = {
         mode: activeMode,
         startDate,
@@ -346,6 +376,8 @@ export default function DashboardPage() {
         messageStyle,
         customMessagePrefix,
         languageConfig,
+        lockedDates,
+        protectExisting,
       };
 
       const timestamps = scheduleEngine.generateCommitTimestamps(config);
@@ -482,6 +514,14 @@ export default function DashboardPage() {
 
           {/* Desktop Summary Pill */}
           <div className="cluster" style={{ gap: '0.65rem' }}>
+            {protectExisting && originalActiveDays > 0 && (
+              <div className="stat-pill" style={{ borderColor: 'rgba(6, 182, 212, 0.4)', background: 'rgba(6, 182, 212, 0.08)' }}>
+                <span className="stat-pill-label" style={{ color: 'var(--cyan-400)' }}>🔒 Preserved</span>
+                <span className="stat-pill-val" style={{ color: 'var(--cyan-400)' }}>
+                  {originalActiveDays} days
+                </span>
+              </div>
+            )}
             <div className="stat-pill">
               <span className="stat-pill-label">Active Days</span>
               <span className="stat-pill-val" style={{ color: 'var(--emerald-400)' }}>
@@ -521,6 +561,9 @@ export default function DashboardPage() {
                 <HeatmapCanvas
                   matrix={customMatrix}
                   onChange={(m) => setCustomMatrix(m)}
+                  existingContributions={existingContributions}
+                  protectExisting={protectExisting}
+                  onToggleProtectExisting={setProtectExisting}
                 />
               </section>
             ) : (
@@ -715,6 +758,14 @@ export default function DashboardPage() {
                 <span style={{ color: 'var(--text-muted)' }}>Commits to Author:</span>
                 <strong style={{ color: 'var(--emerald-400)', fontSize: '1rem' }}>{calculation.totalCommits} commits</strong>
               </div>
+              {calculation.protectedDays && calculation.protectedDays > 0 ? (
+                <div style={{ display: 'flex', justifyContent: 'space-between' }}>
+                  <span style={{ color: 'var(--text-muted)' }}>Original Activity:</span>
+                  <span className="mono" style={{ color: 'var(--cyan-400)', fontWeight: 600 }}>
+                    🔒 {calculation.protectedDays} days preserved
+                  </span>
+                </div>
+              ) : null}
               <div style={{ display: 'flex', justifyContent: 'space-between' }}>
                 <span style={{ color: 'var(--text-muted)' }}>Execution Pipeline:</span>
                 <span className="mono" style={{ fontSize: '0.8rem', color: 'var(--text-muted)' }}>
diff --git a/lib/services/GitHubApiClient.ts b/lib/services/GitHubApiClient.ts
index 3b8b3e3..1f6de86 100644
--- a/lib/services/GitHubApiClient.ts
+++ b/lib/services/GitHubApiClient.ts
@@ -307,6 +307,72 @@ export class GitHubApiClient {
       accessToken
     );
   }
+
+  public async fetchContributionCalendar(
+    username: string,
+    accessToken?: string
+  ): Promise<Record<string, number>> {
+    const query = `
+      query($login: String!) {
+        user(login: $login) {
+          contributionsCollection {
+            contributionCalendar {
+              totalContributions
+              weeks {
+                contributionDays {
+                  date
+                  contributionCount
+                }
+              }
+            }
+          }
+        }
+      }
+    `;
+
+    try {
+      const res = await this.request<{
+        data?: {
+          user?: {
+            contributionsCollection?: {
+              contributionCalendar?: {
+                weeks?: Array<{
+                  contributionDays?: Array<{
+                    date: string;
+                    contributionCount: number;
+                  }>;
+                }>;
+              };
+            };
+          };
+        };
+        errors?: Array<{ message: string }>;
+      }>(
+        'https://api.github.com/graphql',
+        {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ query, variables: { login: username } }),
+        },
+        accessToken
+      );
+
+      const contributionMap: Record<string, number> = {};
+      const weeks = res.data?.user?.contributionsCollection?.contributionCalendar?.weeks || [];
+      for (const week of weeks) {
+        if (!week.contributionDays) continue;
+        for (const day of week.contributionDays) {
+          if (day.date && day.contributionCount > 0) {
+            contributionMap[day.date] = day.contributionCount;
+          }
+        }
+      }
+      return contributionMap;
+    } catch (err) {
+      console.warn(`[GitHubApiClient] Failed to fetch contribution calendar via GraphQL for ${username}:`, err);
+      return {};
+    }
+  }
 }
 
 export const gitHubApiClient = new GitHubApiClient();
diff --git a/lib/services/ScheduleEngine.ts b/lib/services/ScheduleEngine.ts
index 2e2ceef..aa921c7 100644
--- a/lib/services/ScheduleEngine.ts
+++ b/lib/services/ScheduleEngine.ts
@@ -79,10 +79,12 @@ export class ScheduleEngine {
 
   public calculate(config: ScheduleConfig): ScheduleCalculation {
     const repoLabel = `${config.repoOwner || 'user'}/${config.repoName || 'repository'}`;
+    const lockedSet = new Set(config.lockedDates || []);
+    const shouldProtect = config.protectExisting !== false && lockedSet.size > 0;
 
     // 1. Matrix / Canvas Mode
     if (config.mode === 'canvas' && config.customMatrix) {
-      return this.calculateFromMatrix(config.customMatrix, repoLabel);
+      return this.calculateFromMatrix(config.customMatrix, repoLabel, lockedSet, shouldProtect);
     }
 
     // 2. Standard Weekday Mode
@@ -96,6 +98,7 @@ export class ScheduleEngine {
 
     let totalCommits = 0;
     let eligibleDays = 0;
+    let protectedDays = 0;
     const dailyBreakdown: WeekdayCounts = {
       monday: 0,
       tuesday: 0,
@@ -108,6 +111,13 @@ export class ScheduleEngine {
 
     const cur = new Date(startDate);
     while (cur <= endDate) {
+      const dateStr = cur.toISOString().split('T')[0];
+      if (shouldProtect && lockedSet.has(dateStr)) {
+        protectedDays++;
+        cur.setDate(cur.getDate() + 1);
+        continue;
+      }
+
       const dayName = ScheduleEngine.INDEX_TO_WEEKDAY[cur.getDay()];
       const dayCount = Math.max(0, counts[dayName] || 0);
 
@@ -129,15 +139,23 @@ export class ScheduleEngine {
       totalCommits,
       dailyBreakdown,
       estimatedSeconds,
+      protectedDays,
     };
   }
 
-  public calculateFromMatrix(matrix: CustomCommitMatrix, repoLabel: string): ScheduleCalculation {
-    const dates = Object.keys(matrix)
+  public calculateFromMatrix(
+    matrix: CustomCommitMatrix, 
+    repoLabel: string,
+    lockedSet: Set<string> = new Set(),
+    shouldProtect: boolean = false
+  ): ScheduleCalculation {
+    const rawDates = Object.keys(matrix)
       .filter(dateStr => (matrix[dateStr] || 0) > 0)
       .sort();
 
     let totalCommits = 0;
+    let protectedDays = 0;
+    const activeDates: string[] = [];
     const dailyBreakdown: WeekdayCounts = {
       monday: 0,
       tuesday: 0,
@@ -148,7 +166,12 @@ export class ScheduleEngine {
       sunday: 0,
     };
 
-    dates.forEach(dStr => {
+    rawDates.forEach(dStr => {
+      if (shouldProtect && lockedSet.has(dStr)) {
+        protectedDays++;
+        return;
+      }
+      activeDates.push(dStr);
       const count = matrix[dStr];
       const d = new Date(dStr + 'T12:00:00Z');
       const dayName = ScheduleEngine.INDEX_TO_WEEKDAY[d.getUTCDay()];
@@ -156,21 +179,25 @@ export class ScheduleEngine {
       totalCommits += count;
     });
 
-    const dateRange = dates.length > 0
-      ? `${new Date(dates[0]).toDateString()} to ${new Date(dates[dates.length - 1]).toDateString()}`
+    const dateRange = activeDates.length > 0
+      ? `${new Date(activeDates[0]).toDateString()} to ${new Date(activeDates[activeDates.length - 1]).toDateString()}`
       : 'Empty canvas';
 
     return {
       repository: repoLabel,
       dateRange,
-      eligibleDays: dates.length,
+      eligibleDays: activeDates.length,
       totalCommits,
       dailyBreakdown,
       estimatedSeconds: Math.max(3, Math.round(totalCommits * 1.5)),
+      protectedDays,
     };
   }
 
   public generateCommitTimestamps(config: ScheduleConfig): Date[] {
+    const lockedSet = new Set(config.lockedDates || []);
+    const shouldProtect = config.protectExisting !== false && lockedSet.size > 0;
+
     // 1. Matrix / Canvas Mode
     if (config.mode === 'canvas' && config.customMatrix) {
       const timestamps: Date[] = [];
@@ -179,6 +206,10 @@ export class ScheduleEngine {
         .sort();
 
       dates.forEach(dStr => {
+        if (shouldProtect && lockedSet.has(dStr)) {
+          return; // Skip protected date with existing commits
+        }
+
         const count = config.customMatrix![dStr];
         for (let i = 0; i < count; i++) {
           const commitDate = new Date(dStr + 'T00:00:00');
@@ -206,6 +237,12 @@ export class ScheduleEngine {
     const cur = new Date(startDate);
 
     while (cur <= endDate) {
+      const dateStr = cur.toISOString().split('T')[0];
+      if (shouldProtect && lockedSet.has(dateStr)) {
+        cur.setDate(cur.getDate() + 1);
+        continue; // Skip protected date
+      }
+
       const dayName = ScheduleEngine.INDEX_TO_WEEKDAY[cur.getDay()];
       const dayCount = Math.max(0, counts[dayName] || 0);
 
diff --git a/lib/types/scheduler.ts b/lib/types/scheduler.ts
index 1e5213c..86bf3c2 100644
--- a/lib/types/scheduler.ts
+++ b/lib/types/scheduler.ts
@@ -25,6 +25,8 @@ export interface ScheduleConfig {
   messageStyle?: CommitMessageStyle;
   customMessagePrefix?: string;
   languageConfig?: TargetLanguageConfig;
+  lockedDates?: string[];
+  protectExisting?: boolean;
 }
 
 export interface ScheduleCalculation {
@@ -34,6 +36,7 @@ export interface ScheduleCalculation {
   totalCommits: number;
   dailyBreakdown: WeekdayCounts;
   estimatedSeconds: number;
+  protectedDays?: number;
 }
 
 export interface CommitJob {
diff --git a/tests/ScheduleEngine.test.ts b/tests/ScheduleEngine.test.ts
index 5fa003c..306e202 100644
--- a/tests/ScheduleEngine.test.ts
+++ b/tests/ScheduleEngine.test.ts
@@ -135,5 +135,45 @@ describe('ScheduleEngine', () => {
 
       expect(timestamps).toHaveLength(5);
     });
+
+    it('skips protected dates with existing contributions', () => {
+      const timestamps = engine.generateCommitTimestamps({
+        startDate: '2024-01-01',
+        endDate: '2024-01-03',
+        weekdayCounts: {
+          monday: 3,
+          tuesday: 3,
+          wednesday: 3,
+          thursday: 0,
+          friday: 0,
+          saturday: 0,
+          sunday: 0,
+        },
+        lockedDates: ['2024-01-02'],
+        protectExisting: true,
+      });
+
+      // Monday (3) + Tuesday (0 skipped) + Wednesday (3) = 6
+      expect(timestamps).toHaveLength(6);
+      const dates = timestamps.map(t => t.toISOString().split('T')[0]);
+      expect(dates).not.toContain('2024-01-02');
+    });
+
+    it('skips protected dates in canvas mode as well', () => {
+      const timestamps = engine.generateCommitTimestamps({
+        startDate: '',
+        endDate: '',
+        mode: 'canvas',
+        customMatrix: {
+          '2024-05-10': 3,
+          '2024-05-11': 2,
+        },
+        lockedDates: ['2024-05-11'],
+        protectExisting: true,
+      });
+
+      expect(timestamps).toHaveLength(3);
+    });
   });
 });
+